skiima 0.1.000

data/lib/skiima/dependency.rb

@@ -0,0 +1,84 @@
+module Skiima
+  module Dependency
+    class Script
+      attr_accessor :group, :adapter, :version
+      attr_accessor :type, :name, :attr
+      attr_accessor :filename, :content, :sql
+
+      def initialize(group, adapter, version, scriptname)
+        @group, @adapter, @version = group.to_s, adapter.to_s, version.to_s
+        set_attr(scriptname)
+      end
+
+      def filename
+        @filename = [@type,@name,@adapter.to_s,@version,'sql'].join('.')
+      end
+
+      def read_content(direction, root)
+        @content = case 
+        when (direction == :up) then File.open(File.join(root, group, filename)).read
+        when (direction == :down && down_script?) then File.open(File.join(root, group, down_filename)).read
+        end
+      end
+
+      def interpolate_sql(char, vars = {})
+        @sql = Skiima.interpolate_sql(char, @content, vars)
+      end
+
+      private
+
+      def set_attr(scr_name)
+        scr_name = scr_name.split('.')
+        @type, @name = scr_name.shift, scr_name.shift
+        @attr = scr_name
+      end
+
+      def down_filename
+        filename.sub('.sql', '.drop.sql')
+      end
+
+      def down_script?
+        File.exist?(down_filename)
+      end
+    end
+
+    class Reader
+      attr_accessor :scripts
+      attr_accessor :depends, :adapter, :version
+
+      def initialize(depends, adapter, opts = {})
+        @depends, @adapter = depends, adapter.to_sym
+        @version = opts[:version] || :current
+      end
+
+      def adapter
+        case @adapter.to_s
+        when 'mysql', 'mysql2' then :mysql
+        else @adapter
+        end
+      end
+
+      def get_group(g)
+        raise Skiima::SqlGroupNotFound unless depends.has_key?(g)
+        depends[g]
+      end
+
+      def get_adapter(grp)
+        grp.has_key?(adapter) ? (grp[adapter] || {}) : {}
+      end
+
+      def get_scripts(group, version_grp)
+        scr = (version_grp.has_key?(version) ? (version_grp[version] || {}) : {})
+        sc = scr.map {|s| Skiima::Dependency::Script.new(group, adapter, version, s)}
+      end
+
+      def get_load_order(*groups)
+        @scripts = groups.inject([]) do |memo, g|
+          grp = Skiima.symbolize_keys(get_group(g))
+          grp = Skiima.symbolize_keys(get_adapter(grp))
+          memo = memo + get_scripts(g, grp)
+        end
+      end
+    end
+  end
+end

data/lib/skiima/locales/en.yml

@@ -0,0 +1,20 @@
+---
+en:
+  simple: easy
+  date:
+    relative: "%{relative_time} ago"
+
+  messages:
+    errors:
+      open_db_yaml: Could not open Skiima Database Config!
+      open_depends_yaml: Could not open Skiima Depends Config!
+    create:
+      start: Creating objects for @class
+      error: Encountered errors creating @class objects -
+      no_error: All @class objects created successfully!
+      delimiter: =================================
+    drop:
+      start: Dropping objects for @class
+      error: Encountered errors dropping @class objects -
+      no_error: All @class objects dropped successfully!
+      delimiter: =================================

data/lib/skiima/locales/fr.yml

@@ -0,0 +1,2 @@
+fr:
+  translate: S'il vous plait, est-ce que vous ce traduire pour moi?

data/lib/skiima/version.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+module Skiima
+  VERSION = "0.1.000"
+end

data/lib/skiima.rb

@@ -0,0 +1,270 @@
+# encoding: utf-8
+require 'skiima/version'
+
+require 'yaml'
+require 'logger'
+require 'fast_gettext'
+require 'erubis'
+
+require 'skiima_helpers'
+
+# include FastGettext unless it already is
+include FastGettext unless ::Object.included_modules.include?(FastGettext)
+
+module Skiima
+  include FastGettext::Translation
+  extend SkiimaHelpers
+  extend ModuleHelpers
+
+  # require 'skiima/base'
+  autoload :Dependency, 'skiima/dependency'
+  autoload :DbAdapters, 'skiima/db_adapters'
+
+  set_defaults(:config, {
+    :root_path => 'specify/in/config/block',
+    :config_path => 'config',
+    :database_yaml => 'database.yml',
+    :scripts_path => 'db/skiima',
+    :depends_yaml => 'depends.yml',
+    :interpolator => '&',
+    :locale => 'en',
+    :logging_out => 'STDOUT',
+    :logging_level => '3' })
+  #should time zone be added to configs?
+
+  class << self
+    def setup
+      yield self
+      set_translation_repository
+    end
+
+    def new(env, opts = {})
+      Skiima::Loader.new(env, opts)
+    end
+
+    def up(*args)
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+      ski = Skiima.new(env, opts).up(*args)
+    ensure 
+      ski.connection.close
+    end
+
+    def down(*args)
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+      Skiima.new(env, opts).down(*args)
+    ensure
+      ski.connection.close
+    end
+
+    def msg(*args)
+      locale = args.last.is_a?(Symbol) ? args.pop : default_locale
+      lookup = args.join('.')
+      Skiima._(lookup)
+    end
+
+    def log_message(logger, msg)
+      logger.debug msg
+    end
+
+    def default_locale
+      ::Skiima.locale
+    end
+
+    def set_translation_repository
+      FastGettext.add_text_domain('skiima', :path => File.join(File.dirname(__FILE__), 'skiima', 'locales'), :type => :yaml)
+      Skiima.text_domain = 'skiima'
+      Skiima.locale = locale.to_s
+    end
+
+    def self.exe_with_connection(db, &block)
+      resolver = Skiima::DbAdapters::Resolver.new db
+      connection = nil
+
+      begin 
+        connection = self.send(resolver.adapter_method, db)
+        yield connection
+      rescue => ex
+        puts "Oh Noes!!"
+      ensure
+        connection.close
+      end
+    end
+
+    def interpolate_sql(char, sql, vars = {})
+      vars.inject(sql) do |memo, (k,v)| 
+        memo = memo.gsub("#{char}#{k.to_s}", v)
+      end
+    end
+
+    def full_scripts_path(root = self.root_path, config = self.scripts_path)
+      File.join(root, config)
+    end
+
+    def full_database_path(root = self.root_path, config = self.config_path, db = self.database_yaml)
+      File.join(root, config, db)
+    end
+
+    def full_depends_path(root = self.root_path, config = self.scripts_path, depends = self.depends_yaml)
+      File.join(root, config, depends)
+    end
+
+    def read_db_yaml(file)
+      Skiima.symbolize_keys(self.read_yaml_or_throw(file, MissingFileException, "#{Skiima.msg('errors.open_db_yaml')} #{file}"))
+    end
+
+    def read_depends_yaml(file)
+      Skiima.symbolize_keys(self.read_yaml_or_throw(file, MissingFileException, "#{Skiima.msg('errors.open_depends_yaml')} #{file}"))
+    end
+
+    def read_sql_file(folder, file)
+      File.open(File.join(Skiima.full_scripts_path, folder, file)).read
+    end
+
+    def read_yaml_or_throw(file, errclass, errmsg)
+      yaml = begin
+        input = File.read(file)
+        eruby = Erubis::Eruby.new(input)
+        YAML::load(eruby.result(binding())) || {}
+      rescue => ex
+        raise errclass, errmsg
+      end
+
+      Skiima.symbolize_keys(yaml)
+    end
+
+    def method_missing(method, *args, &block)
+      setter = method.to_s.gsub(/=$/, '').to_sym if method.to_s =~ /=$/
+
+      val = case
+        when (@@config.keys.include?(method)) then @@config[method]
+        when (setter and @@config.keys.include?(setter)) then @@config[setter] = args.first
+      end
+
+      val || super
+    end
+  end
+
+  #BaseExceptions
+  class BaseException < ::StandardError; end
+  class MissingFileException < BaseException; end
+  class SqlGroupNotFound < BaseException; end
+  class SqlScriptNotFound < BaseException; end
+
+  #DbAdapterExceptions
+  class AdapterNotSpecified < BaseException; end
+  class LoadError < BaseException; end
+  class StatementInvalid < BaseException; end
+
+  class Loader
+    attr_accessor :config, :logger
+    attr_accessor :db, :connection
+    attr_accessor :scripts
+
+    def initialize(env, opts = {})
+      db_config = Skiima.symbolize_keys(opts[:db] || {})
+
+      self.config = Skiima.config.merge(opts)
+      create_logger
+      @db = Skiima.symbolize_keys(Skiima.read_db_yaml(full_database_path)[env].merge(db_config))
+      make_connection
+      @depends = Skiima.read_depends_yaml(full_depends_path)
+    end
+
+    def up(*args)
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+      reader = Skiima::Dependency::Reader.new(@depends, @db[:adapter], opts)
+      scripts = reader.get_load_order(*args)
+      scripts.each do |s|
+        s.read_content(:up, full_scripts_path)
+        s.interpolate_sql(interpolator, interpolation_vars)
+      end
+      scripts.each {|s| connection.execute(s.sql)}
+    end
+
+    def down(*args)
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+      reader = Skiima::Dependency::Reader.new(@depends, @db[:adapter], opts)
+      scripts = reader.get_load_order(*args).reverse
+      scripts.each do |s|
+        s.read_content(:down, full_scripts_path)
+        s.content ||= connection.drop(s.type, s.name, {:attr => s.attr}.merge(opts))
+        s.interpolate_sql(interpolator, interpolation_vars)
+      end
+      scripts.each {|s| connection.execute(s.sql)}
+    end
+
+    def make_connection
+      resolver = Skiima::DbAdapters::Resolver.new(@db)
+      @connection = Skiima.send(resolver.adapter_method, logger, @db)
+    end
+
+    def log_action(msg, &block)
+      begin
+        logger.debug "[#{Time.now}] Started: #{msg}"
+        results = yield
+        logger.debug "[#{Time.now}] Finished: #{msg}"
+        results
+      rescue
+        logger.error "[#{Time.now}] Error: #{msg}"
+        raise
+      end
+    end
+
+    def log_message(msg)
+      Skiima.log_message(logger, msg)
+    end
+
+    def interpolation_vars(vars = {}) 
+      { :database => db[:database] }.merge(vars)
+    end
+
+    def method_missing(method, *args, &block)
+      setter = method.to_s.gsub(/=$/, '').to_sym if method.to_s =~ /=$/
+
+      val = case 
+        when (@config.keys.include?(method)) then @config[method]
+        when (setter and @config.keys.include?(setter)) then @config[setter] = args
+      end
+
+      val || super
+    end
+
+    private
+
+    def full_database_path
+      Skiima.full_database_path(self.root_path, self.config_path, self.database_yaml)
+    end
+
+    def full_depends_path
+      Skiima.full_depends_path(self.root_path, self.scripts_path, self.depends_yaml)
+    end
+
+    def full_scripts_path
+      Skiima.full_scripts_path(self.root_path, self.scripts_path)
+    end
+
+    def get_logger_out(str)
+      case str
+        when /STDOUT/i then ::STDOUT
+        when /STDERR/i then ::STDERR
+        else File.join(root_path, str)
+      end
+    end
+
+    def get_logger_level(str)
+      case str
+        when '4', /fatal/i then ::Logger::FATAL
+        when '3', /error/i then ::Logger::ERROR
+        when '2', /warn/i  then ::Logger::WARN
+        when '1', /info/i  then ::Logger::INFO
+        when '0', /debug/i then ::Logger::DEBUG
+        else ::Logger::ERROR
+      end
+    end
+
+    def create_logger
+      self.logger = ::Logger.new(get_logger_out(@config[:logging_out]))
+      self.logger.level = get_logger_level(@config[:logging_level])
+    end
+  end
+end

data/lib/skiima_helpers.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+module SkiimaHelpers
+  def symbolize_keys(hash)
+    hash.inject({}) do |options, (key, value)|
+      options[(key.to_sym rescue key) || key] = value
+      options
+    end
+  end
+end
+
+module ModuleHelpers
+  def set_defaults(sym, val)
+  	add_module_attr_reader(sym)
+  	add_module_attr_writer(sym)
+  	class_variable_set("@@#{sym.to_s}", val)
+  end
+
+  alias_method :set_default, :set_defaults
+
+  def add_module_attr_writer(sym)
+    class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+      def self.#{sym}=(obj)
+        @@#{sym} = obj
+      end
+    EOS
+
+    class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+      def #{sym}=(obj)
+        @@#{sym} = obj
+      end
+    EOS
+  end
+
+  def add_module_attr_reader(sym)
+    class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+      @@#{sym} = nil unless defined? @@#{sym}
+
+      def self.#{sym}
+        @@#{sym}
+      end
+    EOS
+
+    class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+      def #{sym}
+        @@#{sym}
+      end
+    EOS
+  end
+end

data/skiima.gemspec

@@ -0,0 +1,53 @@
+# encoding: utf-8
+$:.push File.expand_path("../lib", __FILE__)
+require "skiima/version"
+
+Gem::Specification.new do |s|
+  s.name        = "skiima"
+  s.version     = Skiima::VERSION
+  s.authors     = ["David Conner"]
+  s.email       = ["dconner.pro@gmail.com"]
+  s.homepage    = "http://github.com/dcunited001/skiima"
+  s.summary     = %q{A SQL object manager for Rails projects}
+  s.description = %q{Skiima helps to manage SQL objects like views and functions}
+
+  s.rubyforge_project = "skiima"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "fast_gettext", '~> 0.6.0'
+  s.add_dependency "erubis", '~> 2.7.0'
+
+  s.add_development_dependency "bundler", '>= 1.0.21'
+  s.add_development_dependency "minitest", '~> 2.9.1'
+  s.add_development_dependency "minitest-matchers", '~> 1.1.3'
+  s.add_development_dependency "mocha", '~> 0.10.0'
+  
+end
+
+# Logging
+# TODO: add logging messages
+# TODO: convert to i18n messages
+
+# SQL Objects
+# add functions
+# add procs
+# add triggers
+
+# Adapters
+# SQL Server Adapter
+
+# Skiima Options
+# add a way to just return a list of scripts to be executed
+
+# Refactor:
+# reorganize modules
+
+# Thor tasks ??
+# TODO: thor task to load all sets
+# TODO: thor task to load specific sets
+# TODO: delegate rake tasks to thor (how?)

data/spec/config/database.yml

@@ -0,0 +1,56 @@
+---
+production:
+  adapter: postgresql
+  encoding: utf8
+  database: skiima_production
+  username: skiima
+  password: test
+
+development:
+  adapter: postgresql
+  encoding: utf8
+  database: skiima_development
+  username: skiima
+  password: test
+
+test:
+  adapter: postgresql
+  encoding: utf8
+  database: skiima_test
+  username: skiima
+  password: test
+
+postgresql_test:
+  adapter: postgresql
+  encoding: utf8
+  database: postgresql_test
+  username: skiima
+  password: test
+
+mysql_test:
+  adapter: mysql
+  encoding: utf8
+  reconnect: false
+  database: mysql_test
+  pool: 5
+  username: skiima
+  password: test
+  socket: /tmp/mysql.sock
+
+mysql2_test:
+  adapter: mysql2
+  encoding: utf8
+  reconnect: false
+  database: mysql_test
+  pool: 5
+  username: skiima
+  password: test
+  socket: /tmp/mysql.sock
+
+sqlserver_test:
+  adapter: sqlserver
+  encoding: utf8
+  database: skiima_test
+  username: skiima
+  password: test
+

data/spec/db/skiima/depends.yml

@@ -0,0 +1,61 @@
+---
+init_test_db:
+  mysql:
+    current:
+      - database.skiima_test
+  postgresql:
+    current:
+      - database.skiima_test
+test_table:
+  mysql:
+    current:
+      - table.test_table
+  postgresql:
+    current:
+      - table.test_table
+test_column_names:
+  mysql:
+    current:
+      - table.test_column_names
+  postgresql:
+    current:
+      - table.test_column_names
+test_index:
+  mysql:
+    current:
+      - index.test_index.test_table
+  postgresql:
+    current:
+      - index.test_index.test_table
+test_schema:
+  mysql:
+    current:
+      - schema.test_schema
+  postgresql:
+    current:
+      - schema.test_schema
+test_view:
+  mysql:
+    current:
+      - view.test_view
+  postgresql:
+    current:
+      - view.test_view
+test_rule:
+  postgresql:
+    current:
+      - rule.test_rule.test_view
+test_proc:
+  mysql:
+    current:
+      - proc.test_proc.test_proc
+      - proc.test_proc.test_proc_drop
+blank_group:
+  mysql:
+  postgresql:
+only_pg:
+  mysql:
+  postgresql:
+    current:
+      - table.only_pg
+      - view.pg_only

data/spec/db/skiima/init_test_db/database.skiima_test.mysql.current.sql

@@ -0,0 +1,2 @@
+DROP DATABASE IF EXISTS &database;
+CREATE DATABASE &database;

data/spec/db/skiima/init_test_db/database.skiima_test.postgresql.current.sql

@@ -0,0 +1,2 @@
+DROP DATABASE IF EXISTS &database;
+CREATE DATABASE &database;

data/spec/db/skiima/test_column_names/table.test_column_names.mysql.current.sql

@@ -0,0 +1,8 @@
+DROP TABLE IF EXISTS test_column_names;
+--==================
+CREATE TABLE `test_column_names` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  `first_name` varchar(40) NOT NULL,
+  `last_name` varchar(40) NOT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

data/spec/db/skiima/test_column_names/table.test_column_names.postgresql.current.sql

@@ -0,0 +1,18 @@
+DROP TABLE IF EXISTS test_column_names;
+CREATE TABLE test_column_names (
+  id integer PRIMARY KEY,
+  email character varying(255),
+  encrypted_password character varying(128),
+  reset_password_token character varying(255),
+  reset_password_sent_at timestamp without time zone,
+  remember_created_at timestamp without time zone,
+  sign_in_count integer default 0,
+  current_sign_in_at timestamp without time zone,
+  last_sign_in_at timestamp without time zone,
+  current_sign_in_ip character varying(255),
+  last_sign_in_ip character varying(255),
+  created_at timestamp without time zone not null,
+  updated_at timestamp without time zone not null,
+  alias character varying(255),
+  first_name character varying(255),
+  last_name character varying(255));

data/spec/db/skiima/test_index/index.test_index.mysql.current.sql

@@ -0,0 +1,2 @@
+# Drop index if exists is not available with Mysql
+CREATE INDEX test_index ON test_table (id) USING BTREE;

data/spec/db/skiima/test_index/index.test_index.postgresql.current.sql

@@ -0,0 +1,2 @@
+DROP INDEX IF EXISTS test_index;
+CREATE UNIQUE INDEX test_index ON test_table (id);

data/spec/db/skiima/test_proc/proc.test_proc.mysql.current.sql

@@ -0,0 +1,8 @@
+DROP PROCEDURE IF EXISTS `test_proc`;
+--============
+CREATE PROCEDURE `test_proc`(test INT) 
+BEGIN
+
+  SELECT test;
+
+END;

data/spec/db/skiima/test_proc/proc.test_proc_drop.mysql.current.drop.sql

@@ -0,0 +1 @@
+DROP PROCEDURE IF EXISTS `test_proc_drop`;

data/spec/db/skiima/test_proc/proc.test_proc_drop.mysql.current.sql

@@ -0,0 +1,8 @@
+DROP PROCEDURE IF EXISTS `test_proc_drop`;
+--============
+CREATE PROCEDURE `test_proc_drop`(test INT) 
+BEGIN
+
+  SELECT test;
+
+END;

data/spec/db/skiima/test_rule/rule.test_rule.postgresql.current.sql

@@ -0,0 +1,6 @@
+DROP RULE IF EXISTS test_rule on test_view;
+CREATE RULE test_rule AS 
+ON DELETE TO test_view DO INSTEAD
+
+DELETE FROM test_table tt
+WHERE tt.id = OLD.test_id

data/spec/db/skiima/test_schema/schema.test_schema.postgresql.current.sql

@@ -0,0 +1,2 @@
+DROP SCHEMA IF EXISTS test_schema;
+CREATE SCHEMA test_schema;

data/spec/db/skiima/test_table/table.test_table.mysql.current.sql

@@ -0,0 +1,7 @@
+DROP TABLE IF EXISTS test_table;
+--==================
+CREATE TABLE `test_table` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  `name` varchar(40) NOT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;