dbagile 0.0.1

data/lib/dbagile/command/repo.rb

@@ -0,0 +1 @@
+require 'dbagile/command/repo/create.rb'

data/lib/dbagile/command/robust.rb

@@ -0,0 +1,86 @@
+module DbAgile
+  class Command
+    module Robust
+      include DbAgile::Core::IO::Robustness
+      
+      # Raises an OptionParser::InvalidArgument
+      def bad_argument_list!(rest, expected_name = nil)
+        if rest.empty?
+          raise OptionParser::MissingArgument, "#{expected_name}"
+        else
+          raise OptionParser::InvalidArgument, "#{rest.join(' ')}"
+        end
+      end
+      
+      # Raises an OptionParser::AmbiguousArgument
+      def ambigous_argument_list!
+        raise OptionParser::AmbiguousArgument, "Ambiguous options"
+      end
+      
+      # Parses pending arguments, assert that it contains exactly
+      # types.size arguments, and convert them to types.
+      def valid_argument_list!(rest, *types)
+        if rest.size == types.size
+          result = rest.zip(types).collect do |arg, type|
+            if String == type
+              arg.to_s
+            elsif Symbol == type
+              arg.to_sym
+            elsif Integer
+              arg.to_i
+            else
+              raise OptionParser::InvalidArgument, arg
+            end
+          end
+          result.size == 1 ? result[0] : result
+        elsif rest.size < types.size
+          raise OptionParser::MissingArgument
+        else
+          raise OptionParser::NeedlessArgument, rest
+        end
+      end
+      
+      # Asserts that an argument matches some candidates or
+      # raises a OptionParser::InvalidArgument error.
+      def is_in!(name, value, candidates)
+        value = valid_argument_list!([ value ], candidates.first.class)
+        unless candidates.include?(value)
+          raise OptionParser::InvalidArgument, "Expected one of #{candidates.inspect} for #{name}"
+        end
+        value
+      end
+      
+      # Checks that a file exists and can be read or raises an IO error
+      def valid_read_file!(file)
+        raise IOError, "Unable to read #{file}" unless File.file?(file) and File.readable?(file)
+        file
+      end
+        
+      #
+      # Asserts that a command exists or raises a NoSuchCommandError.
+      # 
+      # @return [DbAgile::Command] the command instance
+      #
+      def has_command!(name, env)
+        cmd = DbAgile::Command.command_for(name, env)
+        if cmd.nil?
+          DbAgile::Command::CATEGORIES.each{|c|
+            cmd = DbAgile::Command.command_for("#{c}:#{name}", env)
+            return cmd if cmd
+          }
+          raise DbAgile::NoSuchCommandError, "No such command #{name.inspect}" 
+        else
+          cmd
+        end
+      end
+      
+      #
+      # Raises a DbAgile::AssumptionFailedError with a specific message
+      #
+      def assumption_error!(msg)
+        raise DbAgile::AssumptionFailedError, msg
+      end
+      
+    end # module Robust
+  end # class Command 
+end # module DbAgile

data/lib/dbagile/command/schema/check.rb

@@ -0,0 +1,59 @@
+module DbAgile
+  class Command
+    module Schema
+      #
+      # Check a database schema
+      #
+      # Usage: dba #{command_name} [SCHEMA.yaml|announced|effective|physical]
+      #
+      # This command informs you about bad smells and good practices with relational
+      # schemas (i.e. forgetting to create keys, not providing unique constraint 
+      # names, and so on).
+      # 
+      # dba #{command_name} SCHEMA.yaml
+      #
+      #   Load the schema from file and check it, printing advices and errors on the 
+      #   message console. The command does not connect any database in this mode.
+      #
+      # dba #{command_name} [announced|effective|physical]
+      #
+      #   Checks a schema of the current database. Announced schema is implicit without
+      #   any argument. This command uses a fallback chain (announced -> effective -> 
+      #   physical) and has no side-effect on the database itself (read-only).
+      #
+      class Check < Command
+        include Schema::Commons
+        Command::build_me(self, __FILE__)
+        
+        # Returns :single
+        def kind_of_schema_arguments
+          :single
+        end
+      
+        # Contribute to options
+        def add_options(opt)
+          self.check_schemas = false
+        end
+        
+        # Executes the command
+        def execute_command
+          with_schema do |schema|
+            errors = schema.check!(false)
+            say("\n")
+            if errors.empty?
+              say("Valid schema (#{schema.schema_identifier.inspect})!", :green)
+              say("\n")
+              [ schema, errors ]
+            else
+              say("Invalid schema (#{schema.schema_identifier.inspect}):", :red)
+              errors.error_messages.each{|m| say("  * #{m}")}
+              say("\n")
+              [ schema, errors ]
+            end
+          end
+        end
+      
+      end # class Check
+    end # module Schema
+  end # class Command
+end # module DbAgile

data/lib/dbagile/command/schema/commons.rb

@@ -0,0 +1,118 @@
+module DbAgile
+  class Command
+    module Schema
+      module Commons
+        
+        # Checks schema(s) first?
+        attr_accessor :check_schemas
+      
+        # Schema arguments
+        attr_accessor :schema_arguments
+      
+        # Adds --[no-]check option
+        def add_check_options(opt)
+          self.check_schemas = true
+          opt.on('--[no-]check', "Perform/Bypass schema checking") do |value|
+            self.check_schemas = value
+          end
+        end
+        
+        # Normalizes a schema argument
+        def normalize_schema_argument(argument)
+          if File.exists?(argument) and File.file?(argument)
+            argument
+          else
+            is_in!("schema", argument, [:announced, :effective, :physical])
+          end
+        end
+        
+        # Normalizes the pending arguments
+        def normalize_schema_arguments(arguments)
+          @schema_arguments = case kind_of_schema_arguments
+            when :single
+              if arguments.empty?
+                [ :announced ]
+              elsif arguments.size == 1
+                arguments.collect{|arg| normalize_schema_argument(arg) }
+              else
+                bad_argument_list!(arguments)
+              end
+            when :double
+              if arguments.empty?
+                [ :effective, :announced ]
+              elsif arguments.size == 2
+                arguments.collect{|arg| normalize_schema_argument(arg) }
+              else
+                bad_argument_list!(arguments)
+              end
+            when :multiple
+              if arguments.size >= 2
+                arguments.collect{|arg| normalize_schema_argument(arg) }
+              else
+                bad_argument_list!(arguments)
+              end
+            else
+              assumption_error!("Unexpected kind of schema argument #{kind_of_schema_arguments}")
+          end
+        end
+
+        # Normalizes the pending arguments
+        def normalize_pending_arguments(arguments)
+          normalize_schema_arguments(arguments)
+        end
+        
+        # Loads a given schema from a schema argument
+        def load_schema(schema_argument, check = self.check_schemas)
+          schema = case schema_argument
+            when Symbol
+              with_current_database do |database|
+                case schema_argument
+                  when :announced
+                    database.announced_schema(true)
+                  when :effective
+                    database.effective_schema(true)
+                  when :physical
+                    database.physical_schema
+                end
+              end
+            when String
+              s = DbAgile::Core::Schema::yaml_file_load(schema_argument)
+              s.schema_identifier = schema_argument
+              s
+          end
+          
+          # A small check, to be sure
+          if schema.nil?
+            assumption_error!("Unexpected schema argument kind #{schema_argument}")
+          end
+              
+          # Check schema if requested
+          if check
+            schema.check!
+          end
+          
+          # Return schema now
+          schema
+        end
+        
+        # Yields the block, passing schemas as an array, according to 
+        # kind_of_schema_arguments
+        def with_schemas(check = self.check_schemas)
+          schemas = schema_arguments.collect{|arg| load_schema(arg, check)}
+          case kind_of_schema_arguments
+            when :single
+              yield(schemas.first)
+            when :double
+              yield(schemas[0], schemas[1])
+            when :multiple
+              yield(schemas)
+            else
+              assumption_error!("Unexpected kind of schema argument #{kind_of_schema_arguments}")
+          end
+        end
+        alias :with_schema :with_schemas
+        
+      end # module Commons
+    end # module Schema
+  end # class Command
+end # module DbAgile

data/lib/dbagile/command/schema/diff.rb

@@ -0,0 +1,101 @@
+module DbAgile
+  class Command
+    module Schema
+      #
+      # Show differences between database schemas
+      #
+      # Usage: dba #{command_name} [schema1 schema2]
+      #
+      # This command is a diff for database schemas, helping database staging
+      # and migrations by showing objects to create/drop/alter.
+      #
+      # dba #{command_name}
+      #
+      #   Shortcut for 'dba schema:diff announced effective'
+      #
+      # dba #{command_name} schema1 schema2
+      #
+      #   Show differences between two particular schemas, being either installed
+      #   schemas [announced|effective|physical] or schema files.  This command 
+      #   uses a fallback chain (announced -> effective -> physical) and has no 
+      #   side-effect on the database itself (read-only).
+      #
+      # NOTE: Schema-checking is on by default, which may lead to checking errors, 
+      #       typically when reverse engineering poorly designed databases. Doing so 
+      #       immediately informs you about a potential problem.
+      #
+      #       Use --no-check to bypass schema checking. See also schema:check.
+      #
+      class Diff < Command
+        include Schema::Commons
+        Command::build_me(self, __FILE__)
+      
+        # Output options
+        attr_reader :output_options
+      
+        # Sets the default options
+        def set_default_options
+          @output_options = {:skip_unchanged => false}
+        end
+    
+        # Contribute to options
+        def add_options(opt)
+          opt.separator nil
+          opt.separator "Options:"
+          add_check_options(opt)
+          opt.on("--[no-]skip-unchanged", "-u",
+                 "Don't show objects that did'nt change") do |value|
+            self.output_options[:skip_unchanged] = value
+          end
+        end
+      
+        # Returns :single
+        def kind_of_schema_arguments
+          :double
+        end
+      
+        # Executes the command
+        def execute_command
+          with_schemas do |left, right|
+            merged = DbAgile::Core::Schema::merge(left, right)
+            show_diff(left, right, merged, environment, output_options)
+            merged
+          end
+        end
+      
+        # Shows difference between left and right
+        def show_diff(left, right, merged, environment, output_options)
+          # Validity
+          if left.looks_valid?
+            lv = environment.color("(valid!)", :green)
+          else
+            lv = environment.color("(INVALID, you'd better run 'dba schema:check --effective')", HighLine::RED + HighLine::BOLD)
+          end
+          if right.looks_valid?
+            rv = environment.color("(valid!)", :green)
+          else
+            rv = environment.color("(INVALID, you'd better run 'dba schema:check')", HighLine::RED + HighLine::BOLD)
+          end
+          
+          # Debug
+          ld, rd = left.schema_identifier.inspect, right.schema_identifier.inspect
+          ld, rd = "#{ld} #{lv}", "#{rd} #{rv}"
+          
+          # Say
+          environment.say '###'
+          environment.say "### LEFT: #{ld}"
+          environment.say "### RIGHT: #{rd}"
+          environment.say '###'
+          environment.say "### " + environment.color('Objects to add on LEFT', :green)
+          environment.say '### ' + environment.color('Objects to remove on LEFT', :red)
+          environment.say '### ' + environment.color('Objects to alter on LEFT', :cyan)
+          environment.say '###'
+          environment.say "\n"
+          merged.yaml_display(environment, output_options)
+          environment.say "\n"
+        end
+        
+      end # class SchemaDump
+    end # module Schema
+  end # class Command
+end # module DbAgile

data/lib/dbagile/command/schema/dump.rb

@@ -0,0 +1,48 @@
+module DbAgile
+  class Command
+    module Schema
+      #
+      # Dump a schema of the current database
+      #
+      # Usage: dba #{command_name} [announced|effective|physical]
+      #
+      # This command dumps the schema of the current database on the output console. 
+      # Without argument, the announced schema is implicit. This command uses the 
+      # fallback chain (announced -> effective -> physical) and has no side-effect 
+      # on the database itself (read-only).
+      #
+      # NOTE: Schema-checking is on by default, which may lead to checking errors, 
+      #       typically when reverse engineering poorly designed databases. Doing so 
+      #       immediately informs you about a potential problem.
+      #
+      #       Use --no-check to bypass schema checking. See also schema:check.
+      #
+      class Dump < Command
+        include Schema::Commons
+        Command::build_me(self, __FILE__)
+        
+        # Contribute to options
+        def add_options(opt)
+          opt.separator nil
+          opt.separator "Options:"
+          add_check_options(opt)
+        end
+        
+        # Returns :single
+        def kind_of_schema_arguments
+          :single
+        end
+      
+        # Executes the command
+        def execute_command
+          with_schema do |schema|
+            say("# Schema of #{schema.schema_identifier.inspect}", :magenta)
+            flush(schema.to_yaml)
+            schema
+          end
+        end
+      
+      end # class SchemaDump
+    end # module Schema
+  end # class Command
+end # module DbAgile

data/lib/dbagile/command/schema/merge.rb

@@ -0,0 +1,55 @@
+module DbAgile
+  class Command
+    module Schema
+      #
+      # Merge a list of schemas
+      #
+      # Usage: dba #{command_name} SCHEMA_ARG, ...
+      #
+      # This command merges all schema in arguments into a single schema and dumps the 
+      # result in YAML on the output console. Schema arguments may be schema files or 
+      # schemas installed on the current database [announced|effective|physical]. This 
+      # command uses the fallback chain (announced -> effective -> physical) and has no 
+      # side-effect on the database itself (read-only).
+      #
+      # NOTE: Schema-checking is on by default and applied on the resulting schema.
+      #       This which may lead to checking errors when reverse engineering poorly 
+      #       designed databases. Doing so immediately informs you about a potential 
+      #       problem.
+      #
+      #       Use --no-check to bypass schema checking. See also schema:check.
+      #
+      class Merge < Command
+        include Schema::Commons
+        Command::build_me(self, __FILE__)
+        
+        # Contribute to options
+        def add_options(opt)
+          opt.separator nil
+          opt.separator "Options:"
+          add_check_options(opt)
+        end
+        
+        # Returns :single
+        def kind_of_schema_arguments
+          :multiple
+        end
+      
+        # Executes the command
+        def execute_command
+          with_schemas(false) do |schemas|
+            empty = DbAgile::Core::Schema::EMPTY_SCHEMA
+            result = schemas.inject(empty){|memo,schema| memo + schema}
+            if self.check_schemas
+              result.check!
+              say("# And the result is valid!", :green)
+            end
+            flush(result.to_yaml)
+            result
+          end
+        end
+      
+      end # class SchemaDump
+    end # module Schema
+  end # class Command
+end # module DbAgile

data/lib/dbagile/command/schema/sql_script.rb

@@ -0,0 +1,124 @@
+module DbAgile
+  class Command
+    module Schema
+      #
+      # Flush a SQL script for a creating/dropping/staging a schema
+      #
+      # Usage: dba #{command_name} {create, drop, stage} [SCHEMA_ARG, ...]
+      #
+      # dba #{command_name} create [announced|effective|physical|FILE.yaml]
+      #
+      #   Flush a SQL script for creating a SQL database from a schema. Announced
+      #   schema of the database is the default. This command uses the fallback chain 
+      #   (announced -> effective -> physical) and has no side-effect on the database 
+      #   itself (read-only).
+      #
+      # dba #{command_name} drop [announced|effective|physical|FILE.yaml]
+      #
+      #   Flush a SQL script for dropping all objects of a SQL database. Announced
+      #   schema of the database is the default. This command uses the fallback chain 
+      #   (announced -> effective -> physical) and has no side-effect on the database 
+      #   itself (read-only).
+      #
+      # dba #{command_name} stage [schema1 schema2]
+      #
+      #   Flush a SQL script for staging a database from schema1 to schema2. Arguments 
+      #   can be installed schemas of the current database or schema files. Effective 
+      #   and announced schema of the current database are respectively used by default. 
+      #   The command uses the fallback chain (announced -> effective -> physical) and 
+      #   has no side-effect on the current database itself (read-only).
+      #
+      # Schema-checking is on by default, which may lead to checking errors, typically 
+      # when reverse engineering poorly designed databases. Doing so immediately informs 
+      # you about a potential problem.
+      #
+      # Use --no-check to bypass schema checking. See also schema:check.
+      #
+      class SqlScript < Command
+        include Schema::Commons
+        Command::build_me(self, __FILE__)
+
+        # Kinds of script
+        SCRIPT_KIND = [:create, :drop, :stage]
+        
+        # Kind of script [:create, :drop, :stage]
+        attr_accessor :script_kind
+        
+        # Contribute to options
+        def add_options(opt)
+          opt.separator nil
+          opt.separator "Options:"
+          add_check_options(opt)
+        end
+        
+        # Returns :single
+        def kind_of_schema_arguments
+          if script_kind == :stage
+            :double
+          else
+            :single
+          end
+        end
+      
+        # Normalizes the pending arguments
+        def normalize_pending_arguments(arguments)
+          case arguments.size
+            when 0
+              bad_argument_list!(arguments, "script kind")
+            else
+              self.script_kind = is_in!("script kind", arguments.shift, SCRIPT_KIND)
+              normalize_schema_arguments(arguments)
+          end
+        end
+        
+        # Executes the command
+        def execute_command
+          case kind_of_schema_arguments
+            when :single
+              execute_single_command
+            when :double
+              execute_double_command
+          end
+        end
+          
+        # Execution for :create and :drop
+        def execute_single_command
+          script = with_schema{|schema|
+            case self.script_kind
+              when :create
+                DbAgile::Core::Schema::create_script(schema)
+              when :drop
+                DbAgile::Core::Schema::drop_script(schema)
+              else
+                raise DbAgile::AssumptionFailedError, "Unknown script kind #{self.script_kind}"
+            end
+          }
+          with_current_connection{|conn|
+            conn.script2sql(script, environment.output_buffer)
+          }
+        end
+      
+        # Execution for :stage
+        def execute_double_command
+          script = with_schemas{|left, right|
+            case self.script_kind
+              when :stage
+                merged = left + right
+                script = DbAgile::Core::Schema::stage_script(merged)
+                if merged.status == DbAgile::Core::Schema::NO_CHANGE
+                  say("Nothing to stage", :magenta)
+                end
+                script
+              else
+                raise DbAgile::AssumptionFailedError, "Unknown script kind #{self.script_kind}"
+            end
+          }
+          with_current_connection{|conn|
+            conn.script2sql(script, environment.output_buffer)
+          }
+        end
+      
+      end # class CreateScript
+    end # module Schema
+  end # class Command
+end # module DbAgile

data/lib/dbagile/command/schema.rb

@@ -0,0 +1,6 @@
+require 'dbagile/command/schema/commons'
+require 'dbagile/command/schema/dump'
+require 'dbagile/command/schema/check'
+require 'dbagile/command/schema/diff'
+require 'dbagile/command/schema/merge'
+require 'dbagile/command/schema/sql_script'

data/lib/dbagile/command/sql/drop.rb

@@ -0,0 +1,40 @@
+module DbAgile
+  class Command
+    module SQL
+      #
+      # Drop a table from a SQL database
+      #
+      # Usage: dba #{command_name} TABLE
+      #
+      # This command issues a "DROP TABLE ..." in the DbAgile's command chain, therefore
+      # targetting the schema of the physical SQL database and bypassing other schemas if
+      # present (announced and effectice schemas in particular). 
+      #
+      # As it may lead to divergences between schemas, and between effective and physical 
+      # schemas in particular, you should consider using schema:* commands instead, when 
+      # possible.
+      # 
+      class Drop < Command
+        Command::build_me(self, __FILE__)
+      
+        # Table which must be dropped
+        attr_accessor :table
+      
+        # Normalizes the pending arguments
+        def normalize_pending_arguments(arguments)
+          self.table = valid_argument_list!(arguments, Symbol)
+        end
+      
+        # Executes the command
+        def execute_command
+          with_current_connection do |connection|
+            connection.transaction do |t|
+              t.drop_table(self.table)
+            end
+          end
+        end
+      
+      end # class Drop
+    end # module SQL
+  end # class Command
+end # module DbAgile

data/lib/dbagile/command/sql/heading.rb

@@ -0,0 +1,34 @@
+module DbAgile
+  class Command
+    module SQL
+      #
+      # Show the heading of a table
+      #
+      # Usage: dba #{command_name} TABLE
+      #
+      # This commands shows a list with columns names and types for a given table
+      # of the current SQL database.
+      #
+      class Heading < Command
+        Command::build_me(self, __FILE__)
+      
+        # Table whose heading must be displayed
+        attr_accessor :dataset
+      
+        # Normalizes the pending arguments
+        def normalize_pending_arguments(arguments)
+          self.dataset = valid_argument_list!(arguments, Symbol)
+        end
+      
+        # Executes the command
+        def execute_command
+          with_current_connection do |connection|
+            heading = connection.heading(self.dataset)
+            flush("{\n" + heading.collect{|pair| "  #{pair[0]}: #{pair[1]}"}.join(",\n") + "\n}\n")
+            heading
+          end
+        end
+      end # class Heading
+    end # # module SQL
+  end # class Command
+end # module DbAgile