skiima 0.1.000 → 0.2.2

data/lib/skiima/db/resolver.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+module Skiima
+  module Db
+
+    class Resolver
+      extend Forwardable
+
+      attr_accessor :db, :orm_module, :connector_klass
+      attr_accessor :adapter
+
+      delegate create_connector: :connector_klass
+
+      def initialize(db_config)
+        merge_db_defaults(db_config)
+        adapter_specified?
+        load_orm_module
+        load_db_connector
+      end
+
+      private
+
+      def merge_db_defaults(opts = {})
+        @db = (db_defaults.merge(Skiima.symbolize_keys(opts)))
+      end
+
+      def db_defaults
+        { orm: 'active_record' }
+      end
+
+      def adapter_specified?
+        raise(AdapterNotSpecified, "database configuration does not specify adapter") unless db.key?(:adapter)
+      end
+
+      def load_db_connector
+        require "skiima/db/connector/#{db[:orm]}/#{db[:adapter]}_connector"
+        @connector_klass = get_db_connector_klass
+      rescue => e
+        raise LoadError, "Adapter does not exist for #{db[:orm]}: #{db[:adapter]} - (#{e.message})", e.backtrace
+      end
+
+      def load_orm_module
+        require "skiima/db/connector/#{db[:orm]}"
+      rescue => e
+        raise LoadError, "Adapter Module does not exist for #{db[:orb]}: (#{e.message})", e.backtrace
+      end
+
+      def get_db_connector_klass
+        #avoiding inflections
+        @connector_klass =
+          case (@orm_module = db[:orm])
+          when 'active_record'
+            case db[:adapter]
+            when 'postgresql' then Skiima::Db::Connector::ActiveRecord::PostgresqlConnector
+            when 'mysql'      then Skiima::Db::Connector::ActiveRecord::MysqlConnector
+            when 'mysql2'     then Skiima::Db::Connector::ActiveRecord::Mysql2Connector
+            end
+          end
+      end
+    end
+
+  end
+end

data/lib/skiima/dependency/reader.rb

@@ -0,0 +1,55 @@
+module Skiima
+  module Dependency
+
+    class Reader
+      attr_accessor :scripts
+      attr_accessor :dependencies, :adapter, :version
+
+      def initialize(dependencies, adapter, opts = {})
+        @dependencies, @adapter = dependencies, 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 dependencies.has_key?(g)
+        dependencies[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)
+        opts = groups.last.is_a?(Hash) ? groups.pop : {}
+        @scripts = groups.inject([]) do |memo, g|
+          grp = get_group(g)
+          scripts = if grp.is_a?(Hash) || (opts[:node] == :internal)
+            get_scripts(g, Skiima.symbolize_keys(read_script_group(grp)))
+          else
+            get_load_order(*(grp.map(&:to_sym)), node: :internal)
+          end
+          memo + scripts
+        end
+      end
+
+      private
+
+      def read_script_group(leaf_node)
+        get_adapter(Skiima.symbolize_keys(leaf_node))
+      end
+    end
+
+  end
+end

data/lib/skiima/dependency/script.rb

@@ -0,0 +1,63 @@
+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 read_upfile(root)
+          when (direction == :down && down_script?(root)) then read_downfile(root)
+        end
+      end
+
+      def interpolate_sql(char, vars = {})
+        @sql = Skiima.interpolate_sql(char, @content, vars)
+      end
+
+      def down_filename
+        filename.sub('.sql', '.drop.sql')
+      end
+
+      def read_upfile(root)
+        File.open(full_filename(root)).read
+      end
+
+      def read_downfile(root)
+        File.open(full_down_filename(root)).read
+      end
+
+      def full_filename(root)
+        File.join(root, group, filename)
+      end
+
+      def full_down_filename(root)
+        File.join(root, group, down_filename)
+      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_script?(root)
+        File.exist?(full_down_filename(root))
+      end
+    end
+
+  end
+end

data/lib/skiima/i18n.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module Skiima
+  module I18n
+
+    def default_locale
+      ::Skiima.locale
+    end
+
+    def msg(*args)
+      # TODO: change to use config.locale
+      locale = args.last.is_a?(Symbol) ? args.pop : default_locale
+      lookup = args.join('.')
+      Skiima._(lookup)
+    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
+
+  end
+end

data/lib/skiima/loader.rb

@@ -0,0 +1,108 @@
+# encoding: utf-8
+module Skiima
+  class Loader
+    extend Forwardable
+    include Skiima::Config
+
+    attr_accessor :env, :vars, :reader, :resolver
+    attr_accessor :dependencies, :db, :connector
+    attr_accessor :direction
+    attr_accessor :scripts
+    attr_accessor :logger
+
+    delegate connection: :connector
+
+    def defaults
+      Skiima.config
+    end
+
+    def initialize(env, opts = {})
+      @env = env
+      merge_db_config(opts.delete('db') || {})
+      get_config(opts)
+      set_vars
+      create_logger
+      create_resolver
+      create_connector
+      get_dependency_config
+      create_dependency_reader
+    end
+
+    def up(*args)
+      @direction = :up
+      read_and_execute(*args)
+      self
+    end
+
+    def down(*args)
+      @direction = :down
+      read_and_execute(*args)
+      self
+    end
+
+    def create_resolver
+      @resolver = Skiima::Db::Resolver.new(db)
+    end
+
+    def create_connector
+      @connector = resolver.create_connector(db, logger)
+    end
+
+    def log_message(msg)
+      Skiima.log_message(logger, msg)
+    end
+
+    def read_and_execute(*scripts)
+      read_scripts *scripts
+      interpolate_each_script
+      execute_each_script
+    end
+
+    private
+
+    def set_vars
+      @vars = config[:vars] || {}
+    end
+
+    def read_scripts(*args)
+      @scripts = reader.get_load_order(*args)
+      @scripts.reverse! if direction == :down
+    end
+
+    def interpolate_each_script
+      scripts.each do |s|
+        s.read_content(direction, full_scripts_path)
+        s.content ||= connector.drop(s.type, s.name, {:attr => s.attr}.merge(config.to_hash)) if direction == :down
+        s.interpolate_sql(interpolator, interpolation_vars)
+      end
+    end
+
+    def execute_each_script
+      scripts.each {|s| connector.execute(s.sql)}
+    end
+
+    def create_dependency_reader
+      @reader = Skiima::Dependency::Reader.new(dependencies, db['adapter'], config)
+    end
+
+    def interpolation_vars
+      { :database => db['database'] }.merge(config[:vars] || {})
+    end
+
+    def get_config(opts)
+      @config = config.merge(opts)
+    end
+
+    def merge_db_config(db_config)
+      @db = read_db_yml(full_database_path)[env].merge(db_config)
+    end
+
+    def get_dependency_config
+      @dependencies = read_dependencies_yml(full_dependencies_path)
+    end
+
+    def create_logger
+      @logger = Skiima::Logger.new config.slice(:logging_out, :logging_level)
+    end
+  end
+end

data/lib/skiima/locales/en.yml

@@ -6,8 +6,8 @@ en:
 
   messages:
     errors:
-      open_db_yaml: Could not open Skiima Database Config!
-      open_depends_yaml: Could not open Skiima Depends Config!
+      open_db_yml: Could not open Skiima Database Config!
+      open_dependencies_yml: Could not open Skiima Dependencies Config!
     create:
       start: Creating objects for @class
       error: Encountered errors creating @class objects -

data/lib/skiima/logger.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+module Skiima
+  class Logger
+    extend Forwardable
+
+    delegate debug: :logger
+    delegate info: :logger
+    delegate warn: :logger
+    delegate error: :logger
+    delegate fatal: :logger
+
+    attr_accessor :logger, :logging_out, :logging_level
+
+    def initialize(opts = {})
+      @logging_out = get_logger_out(opts[:logging_out])
+      @logging_level = get_logger_level(opts[:logging_level])
+      create_logger
+    end
+
+    private
+
+    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
+      @logger = ::Logger.new(logging_out)
+      @logger.level = logging_level
+    end
+
+  end
+
+  module LoggerHelpers
+    def log_message(logger, msg)
+      logger.debug msg
+    end
+  end
+end
+

data/lib/skiima/railtie.rb

@@ -0,0 +1,10 @@
+require "skiima"
+require "rails"
+
+module Skiima
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "skiima/railties/skiima.rake"
+    end
+  end
+end

data/lib/skiima/railties/skiima.rake

@@ -0,0 +1,31 @@
+require "skiima"
+
+namespace :skiima do
+
+  desc "Runs Skiima.up for :default group in dependencies.yml"
+  task :up, [:skiima_env, :group] do
+    args.with_defaults(:skiima_env => 'development', :group => 'default')
+    Skiima.up(args.skiima_env.to_sym, args.group.to_sym)
+  end
+
+  desc "Runs Skiima.down for :default group in dependencies.yml"
+  task :down, [:skiima_env, :group] do
+    args.with_defaults(:skiima_env => 'development', :group => 'default')
+    Skiima.down(args.skiima_env.to_sym, args.group.to_sym)
+  end
+
+  namespace :test do
+    desc "Runs Skiima.up for :test group in dependencies.yml"
+    task :up, [:skiima_env, :group] do
+      args.with_defaults(:skiima_env => 'test', :group => 'test')
+      Skiima.up(args.skiima_env.to_sym, args.group.to_sym)
+    end
+
+    desc "Runs Skiima.down for :test group in dependencies.yml"
+    task :test, [:skiima_env, :group] do
+      args.with_defaults(:skiima_env => 'test', :group => 'test')
+      Skiima.down(args.skiima_env.to_sym, args.group.to_sym)
+    end
+  end
+
+end

data/lib/skiima/version.rb

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

data/skiima.gemspec

@@ -5,6 +5,7 @@ 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"
@@ -22,11 +23,10 @@ Gem::Specification.new do |s|
   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'
-  
+  s.add_development_dependency "bundler", '>= 1.3.3'
+  s.add_development_dependency "minitest", '~> 4.6.2'
+  s.add_development_dependency "minitest-matchers", '~> 1.2.0'
+  s.add_development_dependency "mocha", '~> 0.13.2'
 end
 
 # Logging