ardb 0.0.1 → 0.1.0

data/ardb.gemspec

@@ -19,4 +19,8 @@ Gem::Specification.new do |gem|
 
   gem.add_development_dependency("assert", ["~> 2.0"])
 
+  gem.add_dependency('activerecord',  ["~> 3.2"])
+  gem.add_dependency('activesupport', ["~> 3.2"])
+  gem.add_dependency('ns-options',    ["~> 1.1"])
+
 end

data/bin/ardb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+#
+# Copyright (c) 2011-Present Kelly Redding and Collin Redding
+#
+
+require 'ardb/cli'
+Ardb::CLI.run *ARGV

data/lib/ardb.rb

@@ -1,3 +1,95 @@
+require 'active_record'
+require 'ns-options'
+require 'pathname'
+require 'singleton'
+
 require "ardb/version"
 
-module Ardb; end
+module Ardb
+  NotConfiguredError = Class.new(RuntimeError)
+
+  def self.config; Config; end
+  def self.configure(&block); Config.define(&block); end
+
+  def self.adapter; Adapter.current; end
+
+  def self.validate!
+    if !self.config.required_set?
+      raise NotConfiguredError, "missing required configs"
+    end
+  end
+
+  def self.init(connection=true)
+    validate!
+    Adapter.init
+
+    # setup AR
+    ActiveRecord::Base.logger = self.config.logger
+    ActiveRecord::Base.establish_connection(self.config.db.to_hash) if connection
+  end
+
+  class Config
+    include NsOptions::Proxy
+
+    namespace :db do
+      option :adapter,  String, :required => true
+      option :database, String, :required => true
+      option :encoding, String, :required => false
+      option :url,      String, :required => false
+      option :username, String, :required => false
+      option :password, String, :required => false
+    end
+
+    option :root_path,       Pathname, :required => true
+    option :logger,                    :required => true
+    option :migrations_path, String,   :default => proc{ default_migrations_path }
+    option :schema_path,     String,   :default => proc{ default_schema_path }
+
+    def self.default_migrations_path; root_path.join("db/migrations"); end
+    def self.default_schema_path;     root_path.join("db/schema.rb");  end
+
+  end
+
+  class Adapter
+    include Singleton
+
+    attr_reader :current
+
+    def init
+      @current = Adapter.send(Ardb.config.db.adapter)
+    end
+
+    def reset
+      @current = nil
+    end
+
+    def sqlite
+      require 'ardb/adapter/sqlite'
+      Adapter::Sqlite.new
+    end
+    alias_method :sqlite3, :sqlite
+
+    def postgresql
+      require 'ardb/adapter/postgresql'
+      Adapter::Postgresql.new
+    end
+
+    def mysql
+      require 'ardb/adapter/mysql'
+      Adapter::Mysql.new
+    end
+    alias_method :mysql2, :mysql
+
+    # nice singleton api
+
+    def self.method_missing(method, *args, &block)
+      self.instance.send(method, *args, &block)
+    end
+
+    def self.respond_to?(method)
+      super || self.instance.respond_to?(method)
+    end
+
+  end
+
+end

data/lib/ardb/adapter/base.rb

@@ -0,0 +1,24 @@
+module Ardb; end
+class Ardb::Adapter; end
+class Ardb::Adapter::Base
+
+  attr_reader :config_settings, :database
+
+  def initialize
+    @config_settings = Ardb.config.db.to_hash
+    @database = Ardb.config.db.database
+  end
+
+  def foreign_key_add_sql(*args);  raise NotImplementedError; end
+  def foreign_key_drop_sql(*args); raise NotImplementedError; end
+
+  def create_db(*args); raise NotImplementedError; end
+  def drop_db(*args);   raise NotImplementedError; end
+
+  def drop_tables(*args); raise NotImplementedError; end
+
+  def ==(other_adapter)
+    self.class == other_adapter.class
+  end
+
+end

data/lib/ardb/adapter/mysql.rb

@@ -0,0 +1,22 @@
+require 'ardb'
+require 'ardb/adapter/base'
+
+class Ardb::Adapter
+
+  class Mysql < Base
+
+    def foreign_key_add_sql
+      "ALTER TABLE :from_table"\
+      " ADD CONSTRAINT :name"\
+      " FOREIGN KEY (:from_column)"\
+      " REFERENCES :to_table (:to_column)"
+    end
+
+    def foreign_key_drop_sql
+      "ALTER TABLE :from_table"\
+      " DROP FOREIGN KEY :name"
+    end
+
+  end
+
+end

data/lib/ardb/adapter/postgresql.rb

@@ -0,0 +1,49 @@
+require 'ardb'
+require 'ardb/adapter/base'
+
+class Ardb::Adapter
+
+  class Postgresql < Base
+
+    def public_schema_settings
+      self.config_settings.merge({
+        :database           => 'postgres',
+        :schema_search_path => 'public'
+      })
+    end
+
+    def create_db
+      ActiveRecord::Base.establish_connection(self.public_schema_settings)
+      ActiveRecord::Base.connection.create_database(self.database, self.config_settings)
+      ActiveRecord::Base.establish_connection(self.config_settings)
+    end
+
+    def drop_db
+      ActiveRecord::Base.establish_connection(self.public_schema_settings)
+      ActiveRecord::Base.connection.drop_database(self.database)
+    end
+
+    def drop_tables
+      ActiveRecord::Base.connection.tap do |conn|
+        tables = conn.execute "SELECT table_name"\
+                              " FROM information_schema.tables"\
+                              " WHERE table_schema = 'public';"
+        tables.each{ |row| conn.execute "DROP TABLE #{row['table_name']} CASCADE" }
+      end
+    end
+
+    def foreign_key_add_sql
+      "ALTER TABLE :from_table"\
+      " ADD CONSTRAINT :name"\
+      " FOREIGN KEY (:from_column)"\
+      " REFERENCES :to_table (:to_column)"
+    end
+
+    def foreign_key_drop_sql
+      "ALTER TABLE :from_table"\
+      " DROP CONSTRAINT :name"
+    end
+
+  end
+
+end

data/lib/ardb/adapter/sqlite.rb

@@ -0,0 +1,36 @@
+require 'pathname'
+require 'fileutils'
+require 'ardb'
+require 'ardb/adapter/base'
+
+class Ardb::Adapter
+
+  class Sqlite < Base
+
+    def db_file_path
+      if (path = Pathname.new(self.database)).absolute?
+        path.to_s
+      else
+        Ardb.config.root_path.join(path).to_s
+      end
+    end
+
+    def validate!
+      if File.exist?(self.db_file_path)
+        raise Ardb::Runner::CmdError, "#{self.database} already exists"
+      end
+    end
+
+    def create_db
+      validate!
+      FileUtils.mkdir_p File.dirname(self.db_file_path)
+      ActiveRecord::Base.establish_connection(self.config_settings)
+    end
+
+    def drop_db
+      FileUtils.rm(self.db_file_path) if File.exist?(self.db_file_path)
+    end
+
+  end
+
+end

data/lib/ardb/cli.rb

@@ -0,0 +1,113 @@
+require 'ardb/version'
+require 'ardb/runner'
+
+module Ardb
+
+  class CLI
+
+    def self.run(*args)
+      self.new.run(*args)
+    end
+
+    def initialize
+      @cli = CLIRB.new do
+        option 'root_path', 'root path Ardb should use (`Dir.pwd`)', {
+          :abbrev => 'p', :value => String
+        }
+      end
+    end
+
+    def run(*args)
+      begin
+        @cli.parse!(args)
+        Ardb::Runner.new(@cli.args, @cli.opts).run
+      rescue CLIRB::HelpExit
+        puts help
+      rescue CLIRB::VersionExit
+        puts Ardb::VERSION
+      rescue Ardb::Runner::UnknownCmdError => err
+        $stderr.puts "#{err.message}\n\n"
+        $stderr.puts help
+        exit(1)
+      rescue Ardb::NotConfiguredError, Ardb::Runner::CmdError => err
+        $stderr.puts "#{err.message}"
+        exit(1)
+      rescue Ardb::Runner::CmdFail => err
+        exit(1)
+      rescue CLIRB::Error => exception
+        $stderr.puts "#{exception.message}\n\n"
+        $stderr.puts help
+        exit(1)
+      rescue Exception => exception
+        $stderr.puts "#{exception.class}: #{exception.message}"
+        $stderr.puts exception.backtrace.join("\n")
+        exit(1)
+      end
+      exit(0)
+    end
+
+    def help
+      "Usage: ardb [options] COMMAND\n"\
+      "\n"\
+      "Options:"\
+      "#{@cli}"
+    end
+
+  end
+
+  class CLIRB  # Version 1.0.0, https://github.com/redding/cli.rb
+    Error    = Class.new(RuntimeError);
+    HelpExit = Class.new(RuntimeError); VersionExit = Class.new(RuntimeError)
+    attr_reader :argv, :args, :opts, :data
+
+    def initialize(&block)
+      @options = []; instance_eval(&block) if block
+      require 'optparse'
+      @data, @args, @opts = [], [], {}; @parser = OptionParser.new do |p|
+        p.banner = ''; @options.each do |o|
+          @opts[o.name] = o.value; p.on(*o.parser_args){ |v| @opts[o.name] = v }
+        end
+        p.on_tail('--version', ''){ |v| raise VersionExit, v.to_s }
+        p.on_tail('--help',    ''){ |v| raise HelpExit,    v.to_s }
+      end
+    end
+
+    def option(*args); @options << Option.new(*args); end
+    def parse!(argv)
+      @args = (argv || []).dup.tap do |args_list|
+        begin; @parser.parse!(args_list)
+        rescue OptionParser::ParseError => err; raise Error, err.message; end
+      end; @data = @args + [@opts]
+    end
+    def to_s; @parser.to_s; end
+    def inspect
+      "#<#{self.class}:#{'0x0%x' % (object_id << 1)} @data=#{@data.inspect}>"
+    end
+
+    class Option
+      attr_reader :name, :opt_name, :desc, :abbrev, :value, :klass, :parser_args
+
+      def initialize(name, *args)
+        settings, @desc = args.last.kind_of?(::Hash) ? args.pop : {}, args.pop || ''
+        @name, @opt_name, @abbrev = parse_name_values(name, settings[:abbrev])
+        @value, @klass = gvalinfo(settings[:value])
+        @parser_args = if [TrueClass, FalseClass, NilClass].include?(@klass)
+          ["-#{@abbrev}", "--[no-]#{@opt_name}", @desc]
+        else
+          ["-#{@abbrev}", "--#{@opt_name} #{@opt_name.upcase}", @klass, @desc]
+        end
+      end
+
+      private
+
+      def parse_name_values(name, custom_abbrev)
+        [ (processed_name = name.to_s.strip.downcase), processed_name.gsub('_', '-'),
+          custom_abbrev || processed_name.gsub(/[^a-z]/, '').chars.first || 'a'
+        ]
+      end
+      def gvalinfo(v); v.kind_of?(Class) ? [nil,gklass(v)] : [v,gklass(v.class)]; end
+      def gklass(k); k == Fixnum ? Integer : k; end
+    end
+  end
+
+end

data/lib/ardb/migration_helpers.rb

@@ -0,0 +1,74 @@
+require 'ardb'
+
+module Ardb; end
+module Ardb::MigrationHelpers
+  module_function
+
+  def foreign_key(from_table, from_column, to_table, options={})
+    fk = ForeignKey.new(from_table, from_column, to_table, options)
+    execute(fk.add_sql)
+  end
+
+  def drop_foreign_key(*args)
+    from_table, from_column = args[0..1]
+    options = args.last.kind_of?(Hash) ? args.last : {}
+    fk = ForeignKey.new(from_table, from_column, nil, options)
+    execute(fk.drop_sql)
+  end
+
+  def remove_column_with_fk(table, column)
+    drop_foreign_key(table, column)
+    remove_column(table, column)
+  end
+
+  class ForeignKey
+    attr_reader :from_table, :from_column, :to_table, :to_column, :name, :adapter
+
+    def initialize(from_table, from_column, to_table, options=nil)
+      options ||= {}
+      @from_table  = from_table.to_s
+      @from_column = from_column.to_s
+      @to_table    = to_table.to_s
+      @to_column   = (options[:to_column] || 'id').to_s
+      @name        = (options[:name] || "fk_#{@from_table}_#{@from_column}").to_s
+      @adapter     = Ardb::Adapter.send(Ardb.config.db.adapter)
+    end
+
+    def add_sql
+      apply_data(@adapter.foreign_key_add_sql)
+    end
+
+    def drop_sql
+      apply_data(@adapter.foreign_key_drop_sql)
+    end
+
+    private
+
+    def apply_data(template_sql)
+      template_sql.
+        gsub(':from_table',  @from_table).
+        gsub(':from_column', @from_column).
+        gsub(':to_table',    @to_table).
+        gsub(':to_column',   @to_column).
+        gsub(':name',        @name)
+    end
+  end
+
+  # This file will setup the AR migration command recorder for being able to change our
+  # stuff, require it in an initializer
+
+  module RecorderMixin
+
+    def foreign_key(*args)
+      record(:foreign_key, args)
+    end
+
+    protected
+
+    def invert_foreign_key(args)
+      [ :drop_foreign_key, args ]
+    end
+
+  end
+
+end

data/lib/ardb/runner.rb

@@ -0,0 +1,65 @@
+require 'ardb'
+
+module Ardb; end
+class Ardb::Runner
+  UnknownCmdError = Class.new(ArgumentError)
+  CmdError = Class.new(RuntimeError)
+  CmdFail = Class.new(RuntimeError)
+
+  attr_reader :cmd_name, :cmd_args, :opts, :root_path
+
+  def initialize(args, opts)
+    @opts = opts
+    @cmd_name = args.shift || ""
+    @cmd_args = args
+    @root_path = @opts.delete('root_path') || Dir.pwd
+  end
+
+  def run
+    setup_run
+    case @cmd_name
+    when 'migrate'
+      require 'ardb/runner/migrate_command'
+      MigrateCommand.new.run
+    when 'generate'
+      require 'ardb/runner/generate_command'
+      GenerateCommand.new(@cmd_args).run
+    when 'create'
+      require 'ardb/runner/create_command'
+      CreateCommand.new.run
+    when 'drop'
+      require 'ardb/runner/drop_command'
+      DropCommand.new.run
+    when 'null'
+      NullCommand.new.run
+    else
+      raise UnknownCmdError, "unknown command `#{@cmd_name}`"
+    end
+  end
+
+  private
+
+  def setup_run
+    Ardb.config.root_path = @root_path
+    DbConfigFile.new.require_if_exists
+    Ardb.init(false) # don't establish a connection
+  end
+
+  class DbConfigFile
+    PATH = 'config/db.rb'
+    def initialize
+      @path = Ardb.config.root_path.join(PATH)
+    end
+
+    def require_if_exists
+      require @path.to_s if File.exists?(@path.to_s)
+    end
+  end
+
+  class NullCommand
+    def run
+      # if this was a real command it would do something here
+    end
+  end
+
+end