skiima 0.1.000

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+.rvmrc
+.bundle
+Gemfile.lock
+pkg/*
+
+## Rubymine
+.idea/*
+.idea
+
+## MAC OS
+.DS_Store
+.Trashes
+.com.apple.timemachine.supported
+.fseventsd
+Desktop DB
+Desktop DF
+
+## Spec Logging
+spec/test.log

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - jruby
+  - rbx-19mode
+# uncomment this line if your project needs to run something other than `rake`:
+# script: bundle exec rspec spec

data/CHANGELOG

@@ -0,0 +1,8 @@
+** PRERELEASE 0.0.001
+
+* Determining the layout for modules, classes and tasks
+
+** PRERELEASE 0.0.010
+
+* Major changes to interface.  Added version subgroup.  Removed skiima.yml.  Removed ActiveRecord.
+* Added support for Postgres: databases, schemas, tables, indexes, views, rules.

data/Gemfile

@@ -0,0 +1,30 @@
+# encoding: utf-8
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in skiima.gemspec
+gemspec
+
+group :development do
+  gem 'guard'
+  gem 'guard-minitest'
+  gem 'pry'
+  gem 'rake'
+
+  gem 'pg'
+  gem 'mysql'
+  gem 'mysql2'
+end
+
+if Config::CONFIG['target_os'] =~ /darwin/i
+  gem 'rb-fsevent', '>= 0.3.2'
+  gem 'growl',      '~> 1.0.3'
+end
+if Config::CONFIG['target_os'] =~ /linux/i
+  gem 'rb-inotify', '>= 0.5.1'
+  gem 'libnotify',  '~> 0.1.3'
+end
+if RbConfig::CONFIG['target_os'] =~ /mswin|mingw/i
+  gem 'win32console',             :require => false
+  gem 'rb-fchange',   '~> 0.0.2', :require => false
+  gem 'rb-notifu',    '~> 0.0.4', :require => false
+end

data/Guardfile

@@ -0,0 +1,14 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'minitest', :notify => true do
+  # with Minitest::Unit
+  # watch(%r|^test/test_(.*)\.rb|)
+  # watch(%r|^lib/(.*)([^/]+)\.rb|)     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
+  # watch(%r|^test/test_helper\.rb|)    { "test" }
+
+  # with Minitest::Spec
+  watch(%r|^spec/(.*)_spec\.rb|)
+  watch(%r|^lib/(.*)\.rb|)            { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r|^spec/spec_helper\.rb|)    { "spec" }
+end

data/README.md

@@ -0,0 +1,87 @@
+Skiima: an ORM-Agnostic, Rails-Independent alternative to migrations.
+------------------------
+
+#### Goals:
+Skiima is a work in progress with the following goals:
+
+* Provide a better way to integrate views and functions into Ruby applications.
+* Embeddable in gems to create DB independent extensions.
+* Avoid any unnecessary dependencies or complexity.
+
+I was working on another project and added some cool features that relied on postgres views, rules, etc.  And basically, I needed a place to put these scripts and a way to execute them in a specified order.  
+
+There are alot of cool tricks to use in ActiveRecord with sql objects other than tables.  Not to mention there are performance benefits with the right schema.  Not everything needs to happen at the application layer.
+
+If you have any questions about how things work, look at the tests.  If you have any suggestions, don't hesitate to contact me.
+
+#### Supported Databases:
+##### Postgres
+
+- Schemas
+- Tables
+- Indexes
+- Views
+- Rules
+- Triggers(soon)
+- Functions(soon)
+
+##### Mysql/Mysql2
+
+- Tables
+- Views
+- Indexes
+- Triggers(soon)
+- Functions(soon)
+- Procs(soon)
+
+#### Interface:
+##### Config Files
+Skiima reads two yaml files: database.yml and depends.yml.  
+
+- By default, `database.yml` goes in your `APP_ROOT/config directory`.
+- And similarly, `depends.yml` goes in `APP_ROOT/db/skiima`.
+
+##### Groups
+Skiima allows you to create groups of sql scripts to be executed during migrations.  Each group of sql scripts requires its own folder inside `db/skiima`.
+
+##### Adapter and Version
+Since different databases have different capabilities and object types, you can trigger different scripts to run per adapter.  Furthermore, you can execute different scripts for different versions of a database.  You can also use this version tag if you want to package different sets of functionality.
+
+##### Depends.yml Format
+In the `depends.yml` configuration, add lines for each script in the format.
+
+* `type.name.attr1.attr2`
+
+`attr1` and `attr2` allow you to define the target SQL object and other attributes that need to be passed on a per type basis.  This is only used when Skiima drops your objects without a matching 'drop' script.
+
+##### Filename Format
+Inside each group folder, create sql files with the following format.  These need to match the `depends.yml` configuration.  
+
+* `type.name.adapter.version.sql`
+* `type.name.adapter.version.drop.sql` to override the default drop behavior.
+
+##### Interpolation in Scripts
+You can interpolate variables in your SQL Scripts and then pass in values at runtime with the `:vars` hash.  The default character to use for interpolation is `&`, but this can be changed in the Module initialization.  There are default vars that are substituted, such as `&database`.
+
+##### Module Initialization
+If you're using Rails, you can add a Skiima.setup block in an intializer file to set defaults.  There are other ways to integrate Skiima into your project as well.
+
+    Skiima.setup do |config|
+      config.root_path = Rails.root # changing
+      config.config_path = 'config'
+      config.scripts_path = 'db/skiima'
+      config.locale = :en
+    end
+
+##### Finally, in your Migrations
+Skiima reads the specified groups from depends.yml and compiles a list of scripts to run.  If you're using Rails, substitute `:development` with `Rails.env`
+
+    def up
+      Skiima.up(:development, :group_one, :group_n, :vars => {:var_one => 'db_name'})
+    end
+    
+    def down
+      Skiima.down(:development, :group_one, :group_n, :vars => {:var_one => 'db_name'})
+    end
+
+#### yes, i know i am shamelessly biting activerecord code.  

data/Rakefile

@@ -0,0 +1,56 @@
+# encoding: utf-8
+require 'rubygems'
+require 'rake/testtask'
+require 'bundler/gem_tasks'
+require 'skiima'
+
+SPEC_ROOT = File.join(File.dirname(__FILE__), 'spec')
+
+
+Rake::TestTask.new do |t|
+  t.libs << "spec"
+  t.test_files = FileList['spec/**/*_spec.rb']
+  t.verbose = true
+end
+
+task :default => :test
+
+namespace :test do
+  namespace :prepare do
+
+    task :postgresql do
+      Skiima.setup do |config|
+        config.root_path = SPEC_ROOT
+        config.config_path = 'config'
+        config.scripts_path = 'db/skiima'
+        config.locale = :en
+      end
+
+      db_config = Skiima.read_db_yaml(Skiima.full_database_path)[:development]
+      Skiima.new(:development)
+      Skiima.read_sql_file('init_test_db', 'database.skiima_test.postgresql.current.sql')
+    end
+
+    task :mysql do
+      Skiima.setup do |config|
+        config.root_path = SPEC_ROOT
+        config.config_path = 'config'
+        config.scripts_path = 'db/skiima'
+        config.locale = :en
+      end
+
+      db_config = Skiima.read_db_yaml(Skiima.full_database_path)
+      Skiima.read_sql_file('init_test_db', 'database.skiima_test.mysql.current.sql')
+    end
+
+  end
+end
+
+#desc 'Generate documentation for Skiima.'
+#Rake::RDocTask.new(:rdoc) do |rdoc|
+#  rdoc.rdoc_dir = 'rdoc'
+#  rdoc.title    = 'Skiima'
+#  rdoc.options << '--line-numbers' << '--inline-source'
+#  rdoc.rdoc_files.include('README.rdoc')
+#  rdoc.rdoc_files.include('lib/**/*.rb')
+#end

data/lib/skiima/db_adapters/base_mysql_adapter.rb

@@ -0,0 +1,308 @@
+# encoding: utf-8
+module Skiima
+  module DbAdapters 
+    class BaseMysqlAdapter < Base
+      attr_accessor :version
+
+      LOST_CONNECTION_ERROR_MESSAGES = [
+        "Server shutdown in progress",
+        "Broken pipe",
+        "Lost connection to MySQL server during query",
+        "MySQL server has gone away" ]
+
+      # FIXME: Make the first parameter more similar for the two adapters
+      def initialize(connection, logger, connection_options, config)
+        super(connection, logger)
+        @connection_options, @config = connection_options, config
+        @quoted_column_names, @quoted_table_names = {}, {}
+      end
+
+      def version
+        @version ||= @connection.info[:version].scan(/^(\d+)\.(\d+)\.(\d+)/).flatten.map { |v| v.to_i }
+      end
+
+      def adapter_name #:nodoc:
+        self.class::ADAPTER_NAME
+      end
+
+      # Returns true, since this connection adapter supports migrations.
+      def supports_migrations?
+        true
+      end
+
+      def supports_primary_key?
+        true
+      end
+
+      # Returns true, since this connection adapter supports savepoints.
+      def supports_savepoints?
+        true
+      end
+
+      # Must return the Mysql error number from the exception, if the exception has an
+      # error number.
+      def error_number(exception) # :nodoc:
+        raise NotImplementedError
+      end
+
+      def disable_referential_integrity(&block) #:nodoc:
+        old = select_value("SELECT @@FOREIGN_KEY_CHECKS")
+
+        begin
+          update("SET FOREIGN_KEY_CHECKS = 0")
+          yield
+        ensure
+          update("SET FOREIGN_KEY_CHECKS = #{old}")
+        end
+      end
+
+      # MysqlAdapter has to free a result after using it, so we use this method to write
+      # stuff in a abstract way without concerning ourselves about whether it needs to be
+      # explicitly freed or not.
+      def execute_and_free(sql, name = nil) #:nodoc:
+        yield execute(sql, name)
+      end
+
+      # Executes the SQL statement in the context of this connection.
+      def execute(sql, name = nil)
+        if name == :skip_logging
+          @connection.query(sql)
+        else
+          log(sql, name) { @connection.query(sql) }
+        end
+      rescue StatementInvalid => exception
+        if exception.message.split(":").first =~ /Packets out of order/
+          raise StatementInvalid, "'Packets out of order' error was received from the database. Please update your mysql bindings (gem install mysql) and read http://dev.mysql.com/doc/mysql/en/password-hashing.html for more information. If you're on Windows, use the Instant Rails installer to get the updated mysql bindings."
+        else
+          raise
+        end
+      end
+
+      def begin_db_transaction
+        execute "BEGIN"
+      rescue Exception
+        # Transactions aren't supported
+      end
+
+      def commit_db_transaction #:nodoc:
+        execute "COMMIT"
+      rescue Exception
+        # Transactions aren't supported
+      end
+
+      def rollback_db_transaction #:nodoc:
+        execute "ROLLBACK"
+      rescue Exception
+        # Transactions aren't supported
+      end
+
+      def create_savepoint
+        execute("SAVEPOINT #{current_savepoint_name}")
+      end
+
+      def rollback_to_savepoint
+        execute("ROLLBACK TO SAVEPOINT #{current_savepoint_name}")
+      end
+
+      def release_savepoint
+        execute("RELEASE SAVEPOINT #{current_savepoint_name}")
+      end
+
+      def supported_objects
+        [:database, :table, :view, :index]
+      end
+
+      def tables(name = nil, database = nil, like = nil)
+        sql = "SHOW FULL TABLES "
+        sql << "IN #{database} " if database
+        sql << "WHERE table_type = 'BASE TABLE' "
+        sql << "LIKE '#{like}' " if like
+
+        execute_and_free(sql, 'SCHEMA') do |result|
+          result.collect { |field| field.first }
+        end
+      end
+
+      def views(name = nil, database = nil, like = nil)
+        sql = "SHOW FULL TABLES "
+        sql << "IN #{database} " if database
+        sql << "WHERE table_type = 'VIEW' "
+        sql << "LIKE '#{like}' " if like
+
+        execute_and_free(sql, 'SCHEMA') do |result|
+          result.collect { |field| field.first }
+        end
+      end
+
+      def indexes(name = nil, database = nil, table = nil)
+        sql = "SHOW INDEX "
+        sql << "IN #{table} "
+        sql << "IN #{database} " if database
+        sql << "WHERE key_name = '#{name}'" if name
+
+        execute_and_free(sql, 'SCHEMA') do |result|
+          result.collect { |field| field[2] }
+        end
+      end
+
+      "select routine_schema, routine_name, routine_type from routines;"
+
+      def procs(name = nil, database = nil, like = nil)
+        sql = "SELECT r.routine_name "
+        sql << "FROM information_schema.routines r "
+        sql << "WHERE r.routine_type = 'PROCEDURE' "
+        sql << "AND r.routine_name LIKE '#{like}' " if like
+        sql << "AND r.routine_schema = #{database} " if database
+
+        execute_and_free(sql, 'SCHEMA') do |result|
+          result.collect { |field| field.first }
+        end
+      end
+
+      def database_exists?(name)
+        #stub
+      end
+
+      def table_exists?(name)
+        return false unless name
+        return true if tables(nil, nil, name).any?
+
+        name          = name.to_s
+        schema, table = name.split('.', 2)
+
+        unless table # A table was provided without a schema
+          table  = schema
+          schema = nil
+        end
+
+        tables(nil, schema, table).any?
+      end
+
+      def view_exists?(name)
+        return false unless name
+        return true if views(nil, nil, name).any?
+
+        name          = name.to_s
+        schema, view = name.split('.', 2)
+
+        unless view # A table was provided without a schema
+          view   = schema
+          schema = nil
+        end
+
+        views(nil, schema, view).any?
+      end
+
+      def index_exists?(name, opts = {})
+        target = opts[:attr] ? opts[:attr][0] : nil
+        raise "requires target object" unless target
+
+        return false unless table_exists?(target) #mysql blows up when table doesn't exist
+        return false unless name
+        return true if indexes(name, nil, target).any?
+
+        name           = name.to_s
+        schema, target = name.split('.', 2)
+
+        unless target # A table was provided without a schema
+          target  = schema
+          schema = nil
+        end
+
+        indexes(name, schema, target).any?
+      end
+
+      def proc_exists?(name, opts = {})
+        return false unless name
+        return true if procs(nil, nil, name).any?
+
+        name = name.to_s
+        schema, proc = name.split('.', 2)
+        
+        unless proc # A table was provided without a schema
+          proc  = schema
+          schema = nil
+        end
+
+        procs(name, schema, proc).any?
+      end
+
+      def drop_database(name, opts = {})
+        "DROP DATABASE IF EXISTS #{name}"
+      end
+
+      def drop_table(name, opts = {})
+        "DROP TABLE IF EXISTS #{name}"
+      end
+
+      def drop_view(name, opts = {})
+        "DROP VIEW IF EXISTS #{name}"
+      end
+
+      def drop_index(name, opts = {})
+        target = opts[:attr].first if opts[:attr]
+        raise "requires target object" unless target
+
+        "DROP INDEX #{name} ON #{target}"
+      end
+
+      def column_definitions(table_name)
+        # "SHOW FULL FIELDS FROM #{quote_table_name(table_name)}"
+      end
+
+      def column_names(table_name)
+        sql = "SHOW FULL FIELDS FROM #{quote_table_name(table_name)}"
+        execute_and_free(sql, 'SCHEMA') do |result|
+          result.collect { |field| field.first }
+        end
+      end
+
+      def quote_column_name(name) #:nodoc:
+        @quoted_column_names[name] ||= "`#{name.to_s.gsub('`', '``')}`"
+      end
+
+      def quote_table_name(name) #:nodoc:
+        @quoted_table_names[name] ||= quote_column_name(name).gsub('.', '`.`')
+      end
+
+      def current_database
+        select_value 'SELECT DATABASE() as db'
+      end
+
+      # Returns the database character set.
+      def charset
+        show_variable 'character_set_database'
+      end
+
+      # Returns the database collation strategy.
+      def collation
+        show_variable 'collation_database'
+      end
+
+      def show_variable(name)
+        # variables = select_all("SHOW VARIABLES LIKE '#{name}'")
+        # variables.first['Value'] unless variables.empty?
+      end
+
+      protected
+
+      def translate_exception(exception, message)
+        exception
+        # case error_number(exception)
+        # when 1062
+        #   RecordNotUnique.new(message, exception)
+        # when 1452
+        #   InvalidForeignKey.new(message, exception)
+        # else
+        #   super
+        # end
+      end
+
+      private
+
+      def supports_views?
+        version[0] >= 5
+      end
+    end
+  end
+end

data/lib/skiima/db_adapters/mysql2_adapter.rb

@@ -0,0 +1,114 @@
+# encoding: utf-8
+require 'skiima/db_adapters/base_mysql_adapter'
+
+gem 'mysql2', '~> 0.3.10'
+require 'mysql2'
+
+module Skiima
+  def self.mysql2_connection(logger, config)
+    config[:username] = 'root' if config[:username].nil?
+
+    if Mysql2::Client.const_defined? :FOUND_ROWS
+      config[:flags] = Mysql2::Client::FOUND_ROWS
+    end
+
+    client = Mysql2::Client.new(Skiima.symbolize_keys(config))
+    options = [config[:host], config[:username], config[:password], config[:database], config[:port], config[:socket], 0]
+    Skiima::DbAdapters::Mysql2Adapter.new(client, logger, options, config)
+  end
+
+  module DbAdapters
+    class Mysql2Adapter < BaseMysqlAdapter
+      ADAPTER_NAME = 'Mysql2'
+
+      def initialize(connection, logger, connection_options, config)
+        super
+        configure_connection
+      end
+
+      def supports_explain?
+        true
+      end
+
+      def error_number(exception)
+        exception.error_number if exception.respond_to?(:error_number)
+      end
+
+      def active?
+        return false unless @connection
+        @connection.ping
+      end
+
+      def reconnect!
+        disconnect!
+        connect
+      end
+
+      # Disconnects from the database if already connected.
+      # Otherwise, this method does nothing.
+      def disconnect!
+        unless @connection.nil?
+          @connection.close
+          @connection = nil
+        end
+      end
+
+      def reset!
+        disconnect!
+        connect
+      end
+
+      def execute(sql, name = nil)
+        # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
+        # made since we established the connection
+        # @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
+
+        # relying on formatting inside the file is precisely what i wanted to avoid...
+        results = sql.split(/^--={4,}/).map do |spider_monkey|
+          super(spider_monkey)
+        end
+
+        results.first
+      end
+
+      def exec_query(sql, name = 'SQL', binds = [])
+        result = execute(sql, name)
+        ActiveRecord::Result.new(result.fields, result.to_a)
+      end
+
+      alias exec_without_stmt exec_query
+
+      private
+
+      def connect
+        @connection = Mysql2::Client.new(@config)
+        configure_connection
+      end
+
+      def configure_connection
+        @connection.query_options.merge!(:as => :array)
+
+        variable_assignments = get_var_assignments
+        execute("SET #{variable_assignments.join(', ')}", :skip_logging)
+
+        version
+      end
+
+      def get_var_assignments
+        # By default, MySQL 'where id is null' selects the last inserted id.
+        # Turn this off. http://dev.rubyonrails.org/ticket/6778
+        variable_assignments = ['SQL_AUTO_IS_NULL=0']
+        encoding = @config[:encoding]
+
+        # make sure we set the encoding
+        variable_assignments << "NAMES '#{encoding}'" if encoding
+
+        # increase timeout so mysql server doesn't disconnect us
+        wait_timeout = @config[:wait_timeout]
+        wait_timeout = 2592000 unless wait_timeout.is_a?(Fixnum)
+        variable_assignments << "@@wait_timeout = #{wait_timeout}"
+      end
+
+    end
+  end
+end