dbagile 0.0.1

data/lib/dbagile/command/class_methods.rb

@@ -0,0 +1,103 @@
+module DbAgile
+  class Command
+    module ClassMethods
+      
+      # The command summary
+      attr_reader :summary
+      
+      # The command banner
+      attr_reader :usage
+      
+      # Command description
+      attr_reader :description
+      
+      # Helper to generate command classes 
+      def build_me(command_class, file)
+        rdoc = DbAgile::RubyTools::rdoc_file_paragraphs(file)
+        summary, usage, description = rdoc.shift, rdoc.shift, rdoc.join("\n")
+        command_class.instance_eval{
+          @summary     = summary
+          @usage       = usage.gsub('#{command_name}', command_class.command_name)
+          @description = description.gsub('#{command_name}', command_class.command_name)
+        }
+      end
+      
+      # Tracks subclasses for maintaining subcommand list
+      def inherited(subclass) 
+        super
+        @subclasses ||= [] 
+        @subclasses << subclass 
+      end 
+      
+      # Returns the array of known command sub-classes
+      def subclasses 
+        @subclasses 
+      end
+      
+      # Yields the block with each subclass in turn
+      def each_subclass(&block)
+        subclasses.each(&block)
+      end
+      
+      # Returns the command name of a given class
+      def command_name_of(clazz)
+        name = DbAgile::RubyTools::unqualified_class_name(clazz)
+        name = name.gsub(/[A-Z]/){|x| "-#{x.downcase}"}[1..-1]
+        parent_module = DbAgile::RubyTools::parent_module(clazz)
+        if parent_module == DbAgile::Command
+          name
+        else
+          parent_name = DbAgile::RubyTools::unqualified_class_name(parent_module)
+          "#{parent_name.downcase}:#{name}"
+        end
+      end
+      
+      # Returns command category
+      def category
+        parent = DbAgile::RubyTools::parent_module(self)
+        if parent == DbAgile::Command
+          :dba
+        else
+          DbAgile::RubyTools::unqualified_class_name(parent).to_s.downcase.to_sym
+        end
+      end
+      
+      # Returns command name
+      def command_name
+        command_name_of(self)
+      end
+    
+      # Returns the ruby name of a given class
+      def ruby_method_for(clazz)
+        command_name_of(clazz).gsub(/[:\-]/, '_').to_sym
+      end
+    
+      # Returns a command instance for a given name and environment, 
+      # returns nil if it cannot be found
+      def command_for(name_symbol_or_class, env)
+        subclass = case name_symbol_or_class
+          when String
+            subclasses.find{|subclass| command_name_of(subclass) == name_symbol_or_class}
+          when Symbol
+            subclasses.find{|subclass| ruby_method_for(subclass) == name_symbol_or_class}
+          when Class
+            name_symbol_or_class
+        end
+        subclass.nil? ? nil : subclass.new(env)
+      end
+
+      # Builds command options
+      def build_command_options(options)
+        case options
+          when Array
+            options
+          when String
+            options.split
+          else
+            raise ArgumentError, "Invalid options #{options}"
+        end
+      end
+      
+    end # module ClassMethods
+  end # class Command
+end # module DbAgile

data/lib/dbagile/command/db/add.rb

@@ -0,0 +1,94 @@
+module DbAgile
+  class Command
+    module Db
+      #
+      # Add a new database configuration
+      #
+      # Usage: dba #{command_name} NAME URI
+      #
+      class Add < Command
+        Command::build_me(self, __FILE__)
+      
+        # Database name
+        attr_accessor :db_name
+      
+        # Database URI 
+        attr_accessor :uri
+      
+        # Makes it the current database?
+        attr_accessor :current
+      
+        # Sets the default options
+        def set_default_options
+          @current = true
+        end
+      
+        # Contribute to options
+        def add_options(opt)
+          opt.separator nil
+          opt.separator "Options:"
+          opt.on("--[no-]current", "Set as current database when created (see use)") do |value|
+            self.current = false
+          end
+        end
+      
+        # Normalizes the pending arguments
+        def normalize_pending_arguments(arguments)
+          self.db_name, self.uri = valid_argument_list!(arguments, Symbol, String)
+        end
+      
+        # Checks command 
+        def check_command
+          valid_database_name!(self.db_name)
+          valid_database_uri!(self.uri)
+        end
+      
+        #
+        # Executes the command.
+        #
+        # @return [DbAgile::Core::Database] the created database
+        #
+        def execute_command
+          db = nil
+          with_repository do |repository|
+        
+            if repository.has_database?(self.db_name)
+              raise DatabaseNameConflictError, "Database #{self.db_name} already exists"
+            else
+              # Create the database and adds it
+              name, uri = self.db_name, self.uri
+              db = DbAgile::Core::Database.new(name, uri)
+              repository << db
+              infer_schemas(db) if db.ping?
+        
+              # Makes it the current one if requested
+              if self.current
+                repository.current_db_name = db.name 
+              end
+        
+              # Flush the repository file
+              repository.save!
+            end
+          
+          end
+
+          # List available databases now
+          DbAgile::dba(environment){|dba| dba.db_list %w{}}
+        
+          # Returns created database
+          db
+        end
+        
+        # Infers database schemas
+        def infer_schemas(db)
+          schema = db.physical_schema
+          db.set_announced_schema(schema)
+          db.set_effective_schema(schema)
+        rescue => ex
+          say("An error occured when infering schema: #{ex.message}\nYou'll have to install them manually. Sorry", :magenta)
+        end
+      
+      end # class Add
+    end # module Db
+  end # class Command
+end # module DbAgile

data/lib/dbagile/command/db/list.rb

@@ -0,0 +1,40 @@
+module DbAgile
+  class Command
+    module Db
+      #
+      # List available databases in current repository
+      #
+      # Usage: dba #{command_name}
+      #
+      class List < Command
+        Command::build_me(self, __FILE__)
+      
+        #
+        # Executes the command.
+        #
+        # @return [DbAgile::Core::Repository] the repository instance
+        #
+        def execute_command
+          with_repository do |repository|
+
+            unless repository.empty?
+              flush("Available databases are (#{repository.friendly_path}):")
+              repository.each do |database|
+                msg = repository.current?(database) ? "  -> " : " "*5
+                msg += database.name.to_s.ljust(15)
+                msg += " "
+                msg += database.uri
+                flush(msg)
+              end
+            else
+              say("No database found. Check #{repository.friendly_path}", :magenta)
+            end
+
+            repository
+          end
+        end
+      
+      end # class List
+    end # module Db
+  end # class Command
+end # module DbAgile

data/lib/dbagile/command/db/ping.rb

@@ -0,0 +1,49 @@
+module DbAgile
+  class Command
+    module Db
+      #
+      # Ping a database (current one by default)
+      #
+      # Usage: dba #{command_name} [CONFIG]
+      #
+      class Ping < Command
+        Command::build_me(self, __FILE__)
+      
+        # Name of the database to ping
+        attr_accessor :match
+      
+        # Normalizes the pending arguments
+        def normalize_pending_arguments(arguments)
+          if arguments.empty?
+            self.match = nil
+          else
+            self.match = valid_argument_list!(arguments, Symbol)
+            self.match = valid_database_name!(self.match)
+          end
+        end
+      
+        # Executes the command
+        def execute_command
+          cf = with_repository do |repository|
+        
+            db = has_database!(repository, self.match)
+        
+            # Make the job now
+            begin
+              with_connection(db){|c| c.ping}
+              flush("Ping ok (#{db.uri})")
+              db
+            rescue StandardError => ex
+              flush("Ping KO (#{db.uri})", :red)
+              flush(ex.message)
+              ex
+            end
+          
+          end
+          cf
+        end
+      
+      end # class Ping
+    end # module Db
+  end # class Command
+end # module DbAgile

data/lib/dbagile/command/db/rm.rb

@@ -0,0 +1,52 @@
+module DbAgile
+  class Command
+    module Db
+      #
+      # Remove a database configuration from the repository
+      #
+      # Usage: dba #{command_name} CONFIG
+      #
+      class Rm < Command
+        Command::build_me(self, __FILE__)
+      
+        # Name of the database to remove
+        attr_accessor :match
+      
+        # Normalizes the pending arguments
+        def normalize_pending_arguments(arguments)
+          self.match = valid_argument_list!(arguments, Symbol)
+          self.match = valid_database_name!(self.match)
+        end
+      
+        #
+        # Executes the command.
+        #
+        # @return [DbAgile::Core::Repository] the repository instance
+        #
+        def execute_command
+          cf = with_repository do |repository|
+            db = has_database!(repository, self.match)
+
+            # Move the current one if it was it
+            if repository.current?(db)
+              repository.current_db_name = nil
+            end
+      
+            # Removes it from file
+            repository.remove(db)
+      
+            # Flush the repository file
+            repository.save!
+          end
+        
+          # List available databases now
+          DbAgile::dba(environment){|dba| dba.db_list %w{}}
+        
+          # Returns repository
+          cf
+        end
+      
+      end # class Rm
+    end # module Db
+  end # class Command
+end # module DbAgile

data/lib/dbagile/command/db/stage.rb

@@ -0,0 +1,81 @@
+module DbAgile
+  class Command
+    module Db
+      #
+      # Stage the current database
+      #
+      # Usage: dba #{command_name}
+      #
+      class Stage < Command
+        Command::build_me(self, __FILE__)
+      
+        #
+        # Executes the command.
+        #
+        # @return [DbAgile::Core::Database] the database
+        #
+        def execute_command
+          with_current_database do |db|
+            # left, right and merge
+            left   = db.effective_schema(true)
+            right  = db.announced_schema(true)
+            merged = left + right
+          
+            # Bypass situations
+            if merged.status == DbAgile::Core::Schema::NO_CHANGE
+              say("Nothing to stage", :magenta)
+              return
+            elsif environment.interactive?
+              # Show what will be performed
+              DbAgile::dba(environment){|dba| dba.schema_diff %w{-u effective announced}}
+              say("---")
+              DbAgile::dba(environment){|dba| dba.schema_sql_script %w{stage effective announced}}
+              say("\n")
+              
+              # Ask confirmation now
+              answer = environment.ask("Are you sure?"){|q| q.validate = /^y(es)?|n(o)?|q(uit)?/i}
+              return unless answer =~ /^y/i
+            end
+          
+            # Everything seems ok now!
+            begin
+              stage(db, merged)
+            rescue => ex
+              say("Sorry, staging process failed for some reason.", :red)
+              raise
+            end
+          end
+        end
+        
+        # Makes staging itself
+        def stage(db, merged)
+          script = DbAgile::Core::Schema::stage_script(merged)
+          with_connection(db) do |conn|
+            
+            # stage the real database
+            sql_script = conn.script2sql(script)
+            conn.transaction do |t|
+              t.direct_sql(sql_script)
+              
+              # split schemas now
+              schemas = merged.split{|obj|
+                case obj.status
+                  when DbAgile::Core::Schema::DROPPED
+                    :dropped
+                  else
+                    :effective
+                end
+              }
+              
+              # save schemas
+              if s = schemas[:effective]
+                db.set_effective_schema(s)
+              end
+            end
+          end
+        end
+        
+      end # class Stage
+    end # module Db
+  end # class Command
+end # module DbAgile

data/lib/dbagile/command/db/use.rb

@@ -0,0 +1,48 @@
+module DbAgile
+  class Command
+    module Db
+      #
+      # Set the current database to use
+      #
+      # Usage: dba #{command_name} CONFIG
+      #
+      class Use < Command
+        Command::build_me(self, __FILE__)
+      
+        # Database name
+        attr_accessor :match
+      
+        # Normalizes the pending arguments
+        def normalize_pending_arguments(arguments)
+          self.match = valid_argument_list!(arguments, Symbol)
+          self.match = valid_database_name!(self.match)
+        end
+      
+        #
+        # Executes the command.
+        #
+        # @return [DbAgile::Core::Database] the used database
+        #
+        def execute_command
+          db = nil
+          with_repository do |repository|
+            db = has_database!(repository, self.match)
+
+            # Makes it the current one
+            repository.current_db_name = db.name
+      
+            # Flush the repository file
+            repository.save!
+          end
+
+          # List available databases now
+          DbAgile::dba(environment){|dba| dba.db_list %w{}}
+        
+          # Return current database
+          db
+        end
+      
+      end # class Use
+    end # module Db
+  end # class Command
+end # module DbAgile

data/lib/dbagile/command/db.rb

@@ -0,0 +1,6 @@
+require 'dbagile/command/db/add'
+require 'dbagile/command/db/rm'
+require 'dbagile/command/db/list'
+require 'dbagile/command/db/use'
+require 'dbagile/command/db/ping'
+require 'dbagile/command/db/stage'

data/lib/dbagile/command/dba.rb

@@ -0,0 +1,121 @@
+module DbAgile
+  class Command
+    #
+    # Agile SQL databases and tools for database administrators
+    #
+    # Usage: dba [--help] [--version] 
+    #        dba help <subcommand>
+    #        dba [--repository=DIR] [--use=DB] [--no-interactive] <subcommand> [OPTIONS] [ARGS]
+    #
+    # DbAgile aims at supporting database administrators and developers of database
+    # oriented application. Read more about it on http://blambeau.github.com/dbagile.
+    #
+    class Dba < Command
+      Command::build_me(self, __FILE__)
+      
+      # Continue after my options
+      attr_accessor :stop_after_options
+
+      # Contribute to options
+      def add_options(opt)
+        opt.separator nil
+        opt.separator "Options:"
+        opt.on("--repository=DIR", 
+               "Use a specific repository (current is #{environment.friendly_repository_path})") do |value|
+          environment.repository_path = value
+        end
+        opt.on("--use=DB", 
+               "Use a specific database") do |value|
+          environment.repository.current_db_name = value.to_sym
+        end
+        opt.on("--[no-]interactive", "[Dis-]allow interactive mode") do |value|
+          environment.interactive = value
+        end
+        opt.on("--[no-]backtrace", "Print a backtrace when an error occurs") do |value|
+          environment.show_backtrace = value
+        end
+        opt.on_tail("--help", "Show list of available subcommands") do
+          show_long_help
+          self.stop_after_options = true
+        end
+        opt.on_tail("--version", "Show version") do
+          flush("dba" << " " << DbAgile::VERSION << " (c) 2010, Bernard Lambeau")
+          self.stop_after_options = true
+        end
+      end
+
+      # Returns commands by category
+      def commands_by_categ
+        return @commands_by_categ if @commands_by_categ
+        @commands_by_categ = Hash.new{|h,k| h[k] = []}
+        Command.subclasses.each do |subclass|
+          next if subclass == Dba
+          name     = Command::command_name_of(subclass)
+          command  = Command::command_for(name, environment)
+          category = command.category
+          raise "Unknown command category #{category}" unless DbAgile::Command::CATEGORIES.include?(category)
+          @commands_by_categ[category] << command
+        end
+        @commands_by_categ
+      end
+
+      # Show command help for a specific category
+      def show_commands_help(category)
+        commands_by_categ[category].each do |command|
+          flush(options.summary_indent + command.command_name.ljust(30) + command.summary.to_s)
+        end
+      end
+
+      # Shows the short help
+      def show_short_help
+        flush banner
+        flush options.summarize
+        flush "\n"
+      end
+      alias :show_help :show_short_help
+      
+      # Shows the long help
+      def show_long_help
+        show_short_help
+        DbAgile::Command::CATEGORIES.each{|categ|
+          flush DbAgile::Command::CATEGORY_NAMES[categ]
+          show_commands_help(categ)
+          flush "\n"
+        }
+      end
+      
+      # Runs the command
+      def unsecure_run(requester_file, argv)
+        # My own options
+        my_args = []
+        while argv.first =~ /^--/
+          my_args << argv.shift
+        end
+        options.parse!(my_args)
+        
+        # Invoke sub command
+        unless stop_after_options
+          invoke_subcommand(requester_file, argv) 
+        end
+      rescue Exception => ex
+        environment.on_error(self, ex)
+        environment
+      end
+      
+      # Invokes the subcommand
+      def invoke_subcommand(requester_file, argv)
+        # Command execution
+        if argv.size >= 1
+          DbAgile::Core::Repository::Builder.new(environment).ensure_repository{
+            command = has_command!(argv.shift, environment)
+            command.run(requester_file, argv)
+          }
+        else
+          show_long_help
+        end
+      end
+      
+
+    end # class DbA
+  end # class Command
+end # module DbAgile

data/lib/dbagile/command/help.rb

@@ -0,0 +1,50 @@
+module DbAgile
+  class Command
+    #
+    # Show help of a given command
+    #
+    # Usage: dba #{command_name} COMMAND
+    #
+    class Help < Command
+      Command::build_me(self, __FILE__)
+      
+      # Command name
+      attr_accessor :command
+        
+      # Normalizes the pending arguments
+      def normalize_pending_arguments(arguments)
+        self.command = valid_argument_list!(arguments, String)
+        self.command = has_command!(self.command, environment)
+      end
+      
+      # Executes the command
+      def execute_command
+        flush(command.usage)
+        flush("\n")
+        #
+        flush("Description:")
+        flush("")
+        flush("  " + command.summary)
+        #
+        options = command.options.summarize
+        unless options.empty?
+          flush(options.join)
+          flush("\n")
+        else
+          flush("\n")
+        end
+        #
+        description = command.description.to_s
+        if description.strip.empty?
+          flush("Sorry, no more information available yet")
+        else
+          flush("Detailed documentation:")
+          flush("")
+          flush(description.gsub(/^/, "  ")) 
+          flush("")
+        end
+      end
+      
+    end # class List
+  end # class Command
+end # module DbAgile

data/lib/dbagile/command/repo/create.rb

@@ -0,0 +1,54 @@
+module DbAgile
+  class Command
+    module Repo
+      #
+      # Create a fresh dbagile repository in a specific directory
+      #
+      # Usage: dba #{command_name} [DIR]
+      #
+      # This commands creates a dbagile repository in a directory. When
+      # none is specified, it will create a repository under 'dbagile'
+      # in the current folder.
+      #
+      class Create < Command
+        Command::build_me(self, __FILE__)
+      
+        # Where does the repository must be create?
+        attr_accessor :where
+      
+        # Force repository creation?
+        attr_accessor :force
+      
+        # Contribute to options
+        def add_options(opt)
+          self.force = false
+          opt.separator nil
+          opt.separator "Options:"
+          opt.on("--force", 
+                 "Force creation of the repository, removing the folder if it already exists") do |value|
+            self.force = true
+          end
+        end
+      
+        # Normalizes the pending arguments
+        def normalize_pending_arguments(arguments)
+          if arguments.empty?
+            self.where = "dbagile"
+          else
+            self.where = valid_argument_list!(arguments, String)
+          end
+        end
+      
+        # Executes the command
+        def execute_command
+          if File::exists?(self.where) and self.force
+            FileUtils::rm_rf(self.where)
+          end
+          DbAgile::Core::Repository::create!(self.where)
+          say("Repository successfully created!", :magenta)
+        end
+      
+      end # class Create
+    end # module Repo
+  end # class Command
+end # module DbAgile