skiima 0.1.000 → 0.2.2

data/lib/skiima/dependency.rb

@@ -1,84 +0,0 @@
-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_helpers.rb

@@ -1,49 +0,0 @@
-# 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/spec/skiima/db_adapters/mysql_adapter_spec.rb

@@ -1,38 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-require 'skiima/db_adapters/mysql_adapter'
-
-describe "Skiima::DbAdapters::MysqlAdapter" do
-  let(:db) { Skiima.read_db_yaml(Skiima.full_database_path)[:mysql_test] }
-  let(:mysql_params) { [db[:host], db[:username], db[:password], db[:database], db[:port], db[:socket], Mysql::CLIENT_MULTI_RESULTS] }
-  let(:mysql_adapter) { Skiima::DbAdapters::MysqlAdapter.new(Mysql.init, nil, mysql_params, db) }
-
-  describe "#initialize" do
-    before(:each) do
-      Mysql.any_instance.expects(:real_connect)
-      Skiima::DbAdapters::MysqlAdapter.any_instance.expects(:version)
-      Skiima::DbAdapters::MysqlAdapter.any_instance.expects(:configure_connection)
-    end 
-
-    it 'should set connection options and config' do
-      mysql_adapter.instance_variable_get(:@connection_options).must_equal mysql_params
-      mysql_adapter.instance_variable_get(:@config).must_equal db
-    end
-
-    it 'should set ssl options if included' do
-      db.merge!({:sslkey => '123'})
-      Mysql.any_instance.expects(:ssl_set)
-
-      mysql_adapter
-    end
-
-    it 'should set encoding options if included' do
-      utf = 'utf-8'
-      db.merge!({:encoding => utf})
-      Mysql.any_instance.expects(:options).with(Mysql::SET_CHARSET_NAME, utf)
-
-      mysql_adapter
-    end
-  end
-  
-end

data/spec/skiima/db_adapters/postgresql_adapter_spec.rb

@@ -1,20 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-require 'skiima/db_adapters/postgresql_adapter'
-
-describe "Skiima::DbAdapters::PostgresqlAdapter" do
-  let(:db) { Skiima.read_db_yaml(Skiima.full_database_path)[:test] }
-  let(:pg_params) { [db[:host], db[:port], nil, nil, db[:database], db[:username], db[:password]] }
-  let(:pg_adapter) { Skiima::DbAdapters::PostgresqlAdapter.new(nil, nil, pg_params, db) }
-
-  describe "#initialize" do
-    it 'should set params, attempt to connect, check the version, and get the timezone' do
-      Skiima::DbAdapters::PostgresqlAdapter.any_instance.expects(:connect)
-      Skiima::DbAdapters::PostgresqlAdapter.any_instance.expects(:postgresql_version).returns(80300)
-      Skiima::DbAdapters::PostgresqlAdapter.any_instance.expects(:get_timezone).returns('UTC')
-
-      pg_adapter.version.must_equal 80300
-      pg_adapter.local_tz.must_equal 'UTC'
-    end
-  end
-end

data/spec/skiima/db_adapters_spec.rb

@@ -1,31 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Skiima::DbAdapters::Resolver do
-  let(:db) { Skiima.read_db_yaml(Skiima.full_database_path)[:test] }
-
-  it "should force an adapter to be specified" do
-    proc{ Skiima::DbAdapters::Resolver.new({}) }.must_raise(Skiima::AdapterNotSpecified)
-  end
-
-  it "should raise an error when there is not a valid adapter defined" do
-    db[:adapter] = 'undefsql'
-    proc{ Skiima::DbAdapters::Resolver.new(db) }.must_raise(LoadError)
-  end
-
-  it "should load the adapter class" do
-    # bad test for ordering
-    # proc { Skiima::DbAdapters::PostgresqlAdapter }.must_raise(NameError)
-
-    Skiima::DbAdapters::Resolver.new(db)
-    Skiima::DbAdapters::PostgresqlAdapter.must_be_instance_of Class
-  end
-
-  it "should set the adapter method" do
-    Skiima::DbAdapters::Resolver.new(db).adapter_method.must_equal "postgresql_connection"
-  end
-end
-
-describe Skiima::DbAdapters::Base do
-  
-end