ardb 0.26.0 → 0.27.0

data/ardb.gemspec

@@ -22,6 +22,7 @@ Gem::Specification.new do |gem|
 
   gem.add_dependency('activerecord',  ["~> 3.2"])
   gem.add_dependency('activesupport', ["~> 3.2"])
+  gem.add_dependency('much-plugin',   ["~> 0.1"])
   gem.add_dependency('ns-options',    ["~> 1.1"])
   gem.add_dependency('scmd',          ["~> 3.0"])
 

data/bin/ardb

@@ -4,4 +4,4 @@
 #
 
 require 'ardb/cli'
-Ardb::CLI.run *ARGV
+Ardb::CLI.run ARGV

data/lib/ardb.rb

@@ -22,7 +22,7 @@ module Ardb
     end
   end
 
-  def self.init(establish_connection=true)
+  def self.init(establish_connection = true)
     require self.config.db_file
     validate!
     Adapter.init

data/lib/ardb/adapter/base.rb

@@ -1,86 +1,93 @@
 module Ardb; end
-class Ardb::Adapter; end
-class Ardb::Adapter::Base
-
-  attr_reader :config_settings, :database
-  attr_reader :schema_format, :ruby_schema_path, :sql_schema_path
-
-  def initialize
-    @config_settings = Ardb.config.db_settings
-    @database = Ardb.config.db.database
-    @schema_format = Ardb.config.schema_format
-    schema_path = Ardb.config.schema_path
-    @ruby_schema_path = "#{schema_path}.rb"
-    @sql_schema_path  = "#{schema_path}.sql"
-  end
+class Ardb::Adapter
 
-  def foreign_key_add_sql(*args);  raise NotImplementedError; end
-  def foreign_key_drop_sql(*args); raise NotImplementedError; end
+  class Base
 
-  def create_db(*args); raise NotImplementedError; end
-  def drop_db(*args);   raise NotImplementedError; end
+    attr_reader :config_settings, :database
+    attr_reader :schema_format, :ruby_schema_path, :sql_schema_path
 
-  def migrate_db
-    verbose = ENV["MIGRATE_QUIET"].nil?
-    version = ENV["MIGRATE_VERSION"] ? ENV["MIGRATE_VERSION"].to_i : nil
-    migrations_path = Ardb.config.migrations_path
+    def initialize
+      @config_settings = Ardb.config.db_settings
+      @database = Ardb.config.db.database
+      @schema_format = Ardb.config.schema_format
+      schema_path = Ardb.config.schema_path
+      @ruby_schema_path = "#{schema_path}.rb"
+      @sql_schema_path  = "#{schema_path}.sql"
+    end
 
-    if defined?(ActiveRecord::Migration::CommandRecorder)
-      require 'ardb/migration_helpers'
-      ActiveRecord::Migration::CommandRecorder.class_eval do
-        include Ardb::MigrationHelpers::RecorderMixin
-      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 connect_db
+      ActiveRecord::Base.connection
     end
 
-    ActiveRecord::Migrator.migrations_path = migrations_path
-    ActiveRecord::Migration.verbose = verbose
-    ActiveRecord::Migrator.migrate(migrations_path, version) do |migration|
-      ENV["MIGRATE_SCOPE"].blank? || (ENV["MIGRATE_SCOPE"] == migration.scope)
+    def migrate_db
+      verbose = ENV["MIGRATE_QUIET"].nil?
+      version = ENV["MIGRATE_VERSION"] ? ENV["MIGRATE_VERSION"].to_i : nil
+      migrations_path = Ardb.config.migrations_path
+
+      if defined?(ActiveRecord::Migration::CommandRecorder)
+        require 'ardb/migration_helpers'
+        ActiveRecord::Migration::CommandRecorder.class_eval do
+          include Ardb::MigrationHelpers::RecorderMixin
+        end
+      end
+
+      ActiveRecord::Migrator.migrations_path = migrations_path
+      ActiveRecord::Migration.verbose = verbose
+      ActiveRecord::Migrator.migrate(migrations_path, version) do |migration|
+        ENV["MIGRATE_SCOPE"].blank? || (ENV["MIGRATE_SCOPE"] == migration.scope)
+      end
     end
-  end
 
-  def drop_tables(*args); raise NotImplementedError; end
+    def drop_tables(*args); raise NotImplementedError; end
 
-  def load_schema
-    # silence STDOUT
-    current_stdout = $stdout.dup
-    $stdout = File.new('/dev/null', 'w')
-    load_ruby_schema if @schema_format == :ruby
-    load_sql_schema  if @schema_format == :sql
-    $stdout = current_stdout
-  end
+    def load_schema
+      # silence STDOUT
+      current_stdout = $stdout.dup
+      $stdout = File.new('/dev/null', 'w')
+      load_ruby_schema if @schema_format == :ruby
+      load_sql_schema  if @schema_format == :sql
+      $stdout = current_stdout
+    end
 
-  def load_ruby_schema
-    load @ruby_schema_path
-  end
+    def load_ruby_schema
+      load @ruby_schema_path
+    end
 
-  def load_sql_schema
-    raise NotImplementedError
-  end
+    def load_sql_schema
+      raise NotImplementedError
+    end
 
-  def dump_schema
-    # silence STDOUT
-    current_stdout = $stdout.dup
-    $stdout = File.new('/dev/null', 'w')
-    dump_ruby_schema
-    dump_sql_schema if @schema_format == :sql
-    $stdout = current_stdout
-  end
+    def dump_schema
+      # silence STDOUT
+      current_stdout = $stdout.dup
+      $stdout = File.new('/dev/null', 'w')
+      dump_ruby_schema
+      dump_sql_schema if @schema_format == :sql
+      $stdout = current_stdout
+    end
 
-  def dump_ruby_schema
-    require 'active_record/schema_dumper'
-    FileUtils.mkdir_p File.dirname(@ruby_schema_path)
-    File.open(@ruby_schema_path, 'w:utf-8') do |file|
-      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
+    def dump_ruby_schema
+      require 'active_record/schema_dumper'
+      FileUtils.mkdir_p File.dirname(@ruby_schema_path)
+      File.open(@ruby_schema_path, 'w:utf-8') do |file|
+        ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
+      end
     end
-  end
 
-  def dump_sql_schema
-    raise NotImplementedError
-  end
+    def dump_sql_schema
+      raise NotImplementedError
+    end
+
+    def ==(other_adapter)
+      self.class == other_adapter.class
+    end
 
-  def ==(other_adapter)
-    self.class == other_adapter.class
   end
 
 end

data/lib/ardb/adapter/sqlite.rb

@@ -17,7 +17,7 @@ class Ardb::Adapter
 
     def validate!
       if File.exist?(self.db_file_path)
-        raise Ardb::Runner::CmdError, "#{self.database} already exists"
+        raise RuntimeError, "`#{self.database}` already exists"
       end
     end
 

data/lib/ardb/adapter_spy.rb

@@ -1,6 +1,9 @@
+require 'much-plugin'
+
 module Ardb
 
   module AdapterSpy
+    include MuchPlugin
 
     def self.new(&block)
       block ||= proc{ }
@@ -9,10 +12,8 @@ module Ardb
       record_spy
     end
 
-    def self.included(klass)
-      klass.class_eval do
-        include InstanceMethods
-      end
+    plugin_included do
+      include InstanceMethods
     end
 
     module InstanceMethods
@@ -20,7 +21,7 @@ module Ardb
       attr_accessor :drop_tables_called_count
       attr_accessor :dump_schema_called_count, :load_schema_called_count
       attr_accessor :drop_db_called_count, :create_db_called_count
-      attr_accessor :migrate_db_called_count
+      attr_accessor :connect_db_called_count, :migrate_db_called_count
 
       def drop_tables_called_count
         @drop_tables_called_count ||= 0
@@ -82,6 +83,18 @@ module Ardb
         self.create_db_called_count += 1
       end
 
+      def connect_db_called_count
+        @connect_db_called_count ||= 0
+      end
+
+      def connect_db_called?
+        self.connect_db_called_count > 0
+      end
+
+      def connect_db(*args, &block)
+        self.connect_db_called_count += 1
+      end
+
       def migrate_db_called_count
         @migrate_db_called_count ||= 0
       end

data/lib/ardb/cli.rb

@@ -1,109 +1,272 @@
-require 'ardb/version'
-require 'ardb/runner'
+require 'ardb'
+require 'ardb/clirb'
 
 module Ardb
 
   class CLI
 
-    def self.run(*args)
-      self.new.run(*args)
+    class InvalidCommand;           end
+    class ConnectCommand;           end
+    class CreateCommand;            end
+    class DropCommand;              end
+    class MigrateCommand;           end
+    class GenerateMigrationCommand; end
+    COMMANDS = Hash.new{ |h, k| InvalidCommand.new(k) }.tap do |h|
+      h['connect']            = ConnectCommand
+      h['create']             = CreateCommand
+      h['drop']               = DropCommand
+      h['migrate']            = MigrateCommand
+      h['generate-migration'] = GenerateMigrationCommand
     end
 
-    def initialize
-      @cli = CLIRB.new
+    def self.run(args)
+      self.new.run(args)
     end
 
-    def run(*args)
+    def initialize(kernel = nil, stdout = nil, stderr = nil)
+      @kernel = kernel || Kernel
+      @stdout = stdout || $stdout
+      @stderr = stderr || $stderr
+    end
+
+    def run(args)
       begin
-        @cli.parse!(args)
-        Ardb::Runner.new(@cli.args, @cli.opts).run
+        $LOAD_PATH.push(Dir.pwd) unless $LOAD_PATH.include?(Dir.pwd)
+        Ardb.init(false) # don't establish a connection
+
+        cmd_name = args.shift
+        cmd = COMMANDS[cmd_name].new(args)
+        cmd.run
       rescue CLIRB::HelpExit
-        puts help
+        @stdout.puts cmd.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)
+        @stdout.puts Ardb::VERSION
+      rescue CLIRB::Error, ArgumentError, InvalidCommandError => exception
+        display_debug(exception)
+        @stderr.puts "#{exception.message}\n\n"
+        @stdout.puts cmd.help
+        @kernel.exit 1
+      rescue CommandExitError
+        @kernel.exit 1
+      rescue StandardError => exception
+        @stderr.puts "#{exception.class}: #{exception.message}"
+        @stderr.puts exception.backtrace.join("\n")
+        @kernel.exit 1
+      end
+      @kernel.exit 0
     end
 
-    def help
-      "Usage: ardb [options] COMMAND\n"\
-      "\n"\
-      "Options:"\
-      "#{@cli}"
+    private
+
+    def display_debug(exception)
+      if ENV['DEBUG']
+        @stderr.puts "#{exception.class}: #{exception.message}"
+        @stderr.puts exception.backtrace.join("\n")
+      end
     end
 
-  end
+    InvalidCommandError = Class.new(ArgumentError)
+    CommandExitError    = Class.new(RuntimeError)
+
+    class InvalidCommand
+
+      attr_reader :name, :argv, :clirb
+
+      def initialize(name)
+        @name  = name
+        @argv  = []
+        @clirb = Ardb::CLIRB.new
+      end
+
+      def new(args)
+        @argv = [@name, args].flatten.compact
+        self
+      end
+
+      def run
+        @clirb.parse!(@argv)
+        raise CLIRB::HelpExit if @clirb.args.empty? || @name.to_s.empty?
+        raise InvalidCommandError, "'#{self.name}' is not a command."
+      end
+
+      def help
+        "Usage: ardb [COMMAND] [options]\n\n" \
+        "Commands: #{COMMANDS.keys.sort.join(', ')}\n" \
+        "Options: #{@clirb}"
+      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
+
+    class ConnectCommand
+
+      attr_reader :clirb
+
+      def initialize(argv, stdout = nil, stderr = nil)
+        @argv   = argv
+        @stdout = stdout || $stdout
+        @stderr = stderr || $stderr
+
+        @clirb   = Ardb::CLIRB.new
+        @adapter = Ardb::Adapter.send(Ardb.config.db.adapter)
+      end
+
+      def run
+        @clirb.parse!(@argv)
+        begin
+          Ardb.init
+          @adapter.connect_db
+          @stdout.puts "connected to #{Ardb.config.db.adapter} db `#{Ardb.config.db.database}`"
+        rescue StandardError => e
+          @stderr.puts e
+          @stderr.puts e.backtrace.join("\n")
+          @stderr.puts "error connecting to #{Ardb.config.db.database.inspect} database " \
+                       "with #{Ardb.config.db_settings.inspect}"
+          raise CommandExitError
         end
-        p.on_tail('--version', ''){ |v| raise VersionExit, v.to_s }
-        p.on_tail('--help',    ''){ |v| raise HelpExit,    v.to_s }
       end
+
+      def help
+        "Usage: ardb connect [options]\n\n" \
+        "Options: #{@clirb}"
+      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]
+    class CreateCommand
+
+      attr_reader :clirb
+
+      def initialize(argv, stdout = nil, stderr = nil)
+        @argv   = argv
+        @stdout = stdout || $stdout
+        @stderr = stderr || $stderr
+
+        @clirb   = Ardb::CLIRB.new
+        @adapter = Ardb::Adapter.send(Ardb.config.db.adapter)
+      end
+
+      def run
+        @clirb.parse!(@argv)
+        begin
+          @adapter.create_db
+          @stdout.puts "created #{Ardb.config.db.adapter} db `#{Ardb.config.db.database}`"
+        rescue StandardError => e
+          @stderr.puts e
+          @stderr.puts "error creating #{Ardb.config.db.database.inspect} database"
+          raise CommandExitError
+        end
+      end
+
+      def help
+        "Usage: ardb create [options]\n\n" \
+        "Options: #{@clirb}"
+      end
+
     end
-    def to_s; @parser.to_s; end
-    def inspect
-      "#<#{self.class}:#{'0x0%x' % (object_id << 1)} @data=#{@data.inspect}>"
+
+    class DropCommand
+
+      attr_reader :clirb
+
+      def initialize(argv, stdout = nil, stderr = nil)
+        @argv   = argv
+        @stdout = stdout || $stdout
+        @stderr = stderr || $stderr
+
+        @clirb   = Ardb::CLIRB.new
+        @adapter = Ardb::Adapter.send(Ardb.config.db.adapter)
+      end
+
+      def run
+        @clirb.parse!(@argv)
+        begin
+          @adapter.drop_db
+          @stdout.puts "dropped #{Ardb.config.db.adapter} db `#{Ardb.config.db.database}`"
+        rescue StandardError => e
+          @stderr.puts e
+          @stderr.puts "error dropping #{Ardb.config.db.database.inspect} database"
+          raise CommandExitError
+        end
+      end
+
+      def help
+        "Usage: ardb drop [options]\n\n" \
+        "Options: #{@clirb}"
+      end
+
     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]
+    class MigrateCommand
+
+      attr_reader :clirb
+
+      def initialize(argv, stdout = nil, stderr = nil)
+        @argv   = argv
+        @stdout = stdout || $stdout
+        @stderr = stderr || $stderr
+
+        @clirb   = Ardb::CLIRB.new
+        @adapter = Ardb::Adapter.send(Ardb.config.db.adapter)
+      end
+
+      def run
+        @clirb.parse!(@argv)
+        begin
+          Ardb.init
+          @adapter.migrate_db
+          @adapter.dump_schema unless ENV['ARDB_MIGRATE_NO_SCHEMA']
+        rescue StandardError => e
+          @stderr.puts e
+          @stderr.puts e.backtrace.join("\n")
+          @stderr.puts "error migrating #{Ardb.config.db.database.inspect} database"
+          raise CommandExitError
         end
       end
 
-      private
+      def help
+        "Usage: ardb migrate [options]\n\n" \
+        "Options: #{@clirb}"
+      end
+
+    end
+
+    class GenerateMigrationCommand
+
+      attr_reader :clirb
+
+      def initialize(argv, stdout = nil, stderr = nil)
+        @argv   = argv
+        @stdout = stdout || $stdout
+        @stderr = stderr || $stderr
+
+        @clirb = Ardb::CLIRB.new
+      end
+
+      def run
+        @clirb.parse!(@argv)
+        begin
+          require "ardb/migration"
+          path = Ardb::Migration.new(@clirb.args.first).save!.file_path
+          @stdout.puts "generated #{path}"
+        rescue Ardb::Migration::NoIdentifierError => exception
+          error = ArgumentError.new("MIGRATION-NAME must be provided")
+          error.set_backtrace(exception.backtrace)
+          raise error
+        rescue StandardError => e
+          @stderr.puts e
+          @stderr.puts e.backtrace.join("\n")
+          @stderr.puts "error generating migration"
+          raise CommandExitError
+        end
+      end
 
-      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'
-        ]
+      def help
+        "Usage: ardb generate-migration [options] MIGRATION-NAME\n\n" \
+        "Options: #{@clirb}"
       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