miguel 0.1.0.pre1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1c7f6a7a9e366374d9d88b5c5dde5e3ca0e8e9fa
+  data.tar.gz: 99bc1f4cb8a9ab1bc6f84b8595f541d5226b6f0c
+SHA512:
+  metadata.gz: 3e1d62b3872b4961a7df1276cf82ec89829b81d05560ce3d435d48f9a077bc60e46a919a4b21ae7131e24c01ceb521ebd176120525a01ff7f8d989be66335835
+  data.tar.gz: 483d87a4bd5c54251dce7255e99e54238ddcc6a729d820c881fe841153732854b55b697895b0749d3cd6a07533ea237a43c66abb40dd6b0b4678436f4324908e

data/.gitignore

@@ -0,0 +1 @@
+*~

data/Rakefile

@@ -0,0 +1,10 @@
+# Rake makefile.
+
+task :default => :test
+
+desc 'Run tests'
+task :test do
+  sh "bacon --automatic --quiet"
+end
+
+# EOF #

data/TODO

@@ -0,0 +1,2 @@
+add tests
+write docs

data/bin/miguel

@@ -0,0 +1,9 @@
+#! /usr/bin/env ruby
+
+$:.unshift File.dirname( __FILE__ ) + '/../lib'
+
+require 'miguel/command'
+
+Miguel::Command.new.run( ARGV )
+
+# EOF #

data/lib/miguel/command.rb

@@ -0,0 +1,242 @@
+# Command line driver.
+
+require 'miguel'
+require 'optparse'
+
+module Miguel
+
+  # Miguel command line interface.
+  class Command
+
+    attr_reader :env, :format, :loggers, :force, :quiet, :trace
+
+    # Initialize the command options.
+    def init
+      @env = nil
+      @format = nil
+      @loggers = []
+      @force = nil
+      @quiet = nil
+      @trace = nil
+    end
+
+    # Run the command.
+    def run( args )
+      args = args.dup
+      init
+      OptionParser.new( &method( :set_opts ) ).parse!( args )
+      execute( args )
+      exit 0
+    rescue Exception => e
+      raise if trace or e.is_a?( SystemExit )
+      $stderr.print "#{e.class}: " unless e.is_a?( RuntimeError )
+      $stderr.puts e.message
+      exit 1
+    end
+
+    private
+
+    # Set the command options.
+    def set_opts( opts )
+      opts.banner = "Miguel: The Database Migrator and Migration Generator for Sequel"
+      opts.define_head "Usage: miguel [options] <command> <db|schema> [db|schema]"
+      opts.separator ""
+      opts.separator "Examples:"
+      opts.separator "  miguel show mysql://localhost/main"
+      opts.separator "  miguel dump schema.rb"
+      opts.separator "  miguel diff db.yml test.yml"
+      opts.separator "  miguel apply db.yml schema.rb"
+      opts.separator ""
+      opts.separator "Commands:"
+      opts.separator "  show <db|schema>                   Show schema of given database or schema file"
+      opts.separator "  dump <db|schema>                   Dump migration which creates given schema"
+      opts.separator "  down <db|schema>                   Dump migration which reverses given schema"
+      opts.separator "  diff <db|schema> <db|schema>       Dump migration needed to migrate to the second schema"
+      opts.separator "  apply <db> <db|schema>             Apply given schema to the database"
+      opts.separator "  clear <db>                         Drop all tables in given database"
+      opts.separator ""
+      opts.separator "Options:"
+
+      opts.on_tail( '-h', '-?', '--help', 'Show this message' ) do
+        puts opts
+        exit
+      end
+
+      opts.on( '-e', '--env <env>', 'Use given environment config for database(s)' ) do |v|
+        @env = v
+      end
+
+      opts.on( '-E', '--echo', 'Echo SQL statements' ) do
+        require 'logger'
+        @loggers << Logger.new( $stdout )
+      end
+
+      opts.on( '-f', '--force', 'Force changes to be applied without confirmation' ) do
+        @force = true
+      end
+
+      opts.on( '-l', '--log <file>', 'Log SQL statements to given file' ) do |v|
+        require 'logger'
+        @loggers << Logger.new( v )
+      end
+
+      formats = [ :bare, :change, :full ]
+      opts.on( '-m', '--migration <format>', formats, "Select format for dumped migrations (#{formats.join(', ')})" ) do |v|
+        @format = v
+      end
+
+      opts.on( '-q', '--quiet', "Don't display the changes to be applied" ) do
+        @quiet = true
+      end
+
+      opts.on( '-t', '--trace', 'Show full backtrace if an exception is raised' ) do
+        @trace = true
+      end
+
+      opts.on_tail( '-v', '--version', 'Print version' ) do
+        puts "miguel #{Miguel::VERSION}"
+        exit
+      end
+    end
+
+    # Execute the command itself.
+    def execute( args )
+      command = args.shift or fail "Missing command, use -h to see usage."
+      case command
+      when 'show'
+        check_args( args, 1 )
+        schema = get_schema( args.shift )
+        print schema.dump
+      when 'dump'
+        check_args( args, 1 )
+        schema = get_schema( args.shift )
+        show_changes( Schema.new, schema )
+      when 'down'
+        check_args( args, 1 )
+        schema = get_schema( args.shift )
+        show_changes( schema, Schema.new )
+      when 'diff'
+        check_args( args, 2 )
+        old_schema = get_schema( args.shift )
+        new_schema = get_schema( args.shift )
+        show_changes( old_schema, new_schema )
+      when 'apply'
+        check_args( args, 2 )
+        db = get_db( args.shift )
+        schema = get_schema( args.shift )
+        apply_schema( db, schema )
+      when 'clear'
+        check_args( args, 1 )
+        db = get_db( args.shift )
+        apply_schema( db, Schema.new )
+      else
+        fail "Invalid command, use -h to see usage."
+      end
+    end
+
+    # Make sure the argument count is as expected.
+    def check_args( args, count )
+      fail "Not enough arguments present', use -h to see usage." if args.count < count
+      fail "Extra arguments present', use -h to see usage." if args.count > count
+    end
+
+    # Import schema from given database.
+    def import_schema( db )
+      Importer.new( db ).schema
+    end
+
+    # Get schema from given schema file or database.
+    def get_schema( name )
+      schema = if name.nil? or name.empty?
+        fail "Missing database or schema name."
+      elsif File.exist?( name ) and name =~ /\.rb\b/
+        Schema.load( name ) or fail "No schema loaded from file '#{name}'."
+      else
+        db = get_db( name )
+        import_schema( db )
+      end
+      schema
+    end
+
+    # Connect to given database.
+    def get_db( name )
+      db = if name.nil? or name.empty?
+        fail "Missing database name."
+      elsif File.exist?( name )
+        require 'yaml'
+        config = YAML.load_file( name )
+        env = self.env || "development"
+        config = config[ env ] || config[ env.to_sym ] || config
+        config.keys.each{ |k| config[ k.to_sym ] = config.delete( k ) }
+        Sequel.connect( config )
+      else
+        Sequel.connect( name )
+      end
+      db.loggers = loggers
+      db
+    end
+
+    # Show changes between the two schemas.
+    def show_changes( from, to )
+      m = Migrator.new
+      case format
+      when nil, :bare
+        print m.changes( from, to )
+      when :change
+        print m.change_migration( from, to )
+      when :full
+        print m.full_migration( from, to )
+      end
+    end
+
+    # Apply given schema to given database.
+    def apply_schema( db, schema )
+      from = import_schema( db )
+      changes = Migrator.new.changes( from, schema ).to_s
+
+      if changes.empty?
+        puts "No changes are necessary." unless quiet
+        return
+      end
+
+      unless quiet
+        puts "These changes will be applied to the database:"
+        print changes
+      end
+
+      unless force
+        fail "OK, aborting." unless confirm?
+      end
+
+      db.instance_eval( changes )
+
+      puts "OK, those changes were applied." unless quiet
+    end
+
+    # Ask the user for a confirmation.
+    def confirm?
+      loop do
+        print "Confirm (yes or no)? "
+
+        unless line = $stdin.gets
+          puts
+          puts "I take EOF as 'no'. Use --force if you want to skip the confirmation instead."
+          return
+        end
+
+        case line.chomp.downcase
+        when 'yes'
+          return true
+        when 'no'
+          return false
+        else
+          puts "Please answer 'yes' or 'no'."
+        end
+      end
+    end
+
+  end
+
+end
+
+# EOF #

data/lib/miguel/dumper.rb

@@ -0,0 +1,45 @@
+# Simple dumper.
+
+module Miguel
+
+  # Class for dumping indented code blocks.
+  class Dumper
+
+    # Create new dumper.
+    def initialize( out = [], step = 2 )
+      @out = out
+      @indent = 0
+      @step = step
+    end
+
+    # Get all output gathered so far as a string.
+    def text
+      @out.join
+    end
+
+    alias to_s text
+
+    # Append given line/block to the output.
+    #
+    # If block is given, it is automatically enclosed between do/end keywords
+    # and anything dumped within it is automatically indented.
+    def dump( line )
+      if block_given?
+        dump "#{line} do"
+        @indent += @step
+        yield
+        @indent -= @step
+        dump "end"
+      else
+        @out << "#{' ' * @indent}#{line}\n"
+      end
+      self
+    end
+
+    alias << dump
+
+  end
+
+end
+
+# EOF #

data/lib/miguel/importer.rb

@@ -0,0 +1,232 @@
+# Sequel schema import.
+
+require 'miguel/schema'
+
+module Miguel
+
+  # Class for importing database schema from Sequel database.
+  class Importer
+
+    # The database we operate upon.
+    attr_reader :db
+
+    # Create new instance for importing schema from given database.
+    def initialize( db )
+      @db = db
+    end
+
+    private
+
+    # Which characrets we convert when parsing enum values.
+    # Quite likely not exhaustive, but sufficient for our purposes.
+    ESCAPED_CHARS = {
+      "''" => "'",
+      "\\\\" => "\\",
+      "\\n" => "\n",
+      "\\t" => "\t",
+    }
+
+    # Regexp matching escaped sequences in enum values.
+    ESCAPED_CHARS_RE = /''|\\./
+
+    # Parse the element values for enum/set types.
+    def parse_elements( string )
+      string.scan(/'((?:[^']|'')*)'/).flatten.map do
+        |x| x.gsub( ESCAPED_CHARS_RE ){ |c| ESCAPED_CHARS[ c ] || c }
+      end
+    end
+
+    # Convert given database type to type and optional options used by our schema definitions.
+    # The ruby type provided serves as a hint of what Sequel's idea of the type is.
+    def revert_type_literal_internal( type, ruby_type )
+
+      return :boolean, :default_size => 1 if ruby_type == :boolean
+
+      case db.database_type
+      when :mysql
+        case type
+        when /\Aint\(\d+\)\z/
+          return :integer, :default_size => 11
+        when /\Aint\(\d+\) unsigned\z/
+          return :integer, :unsigned => true, :default_size => 10
+        when /\Abigint\(\d+\)\z/
+          return :bigint, :default_size => 20
+        when /\Adecimal\(\d+,\d+\)\z/
+          return :decimal, :default_size => [ 10, 0 ]
+        when /\A(enum|set)\((.*)\)\z/
+          return $1.to_sym, :elements => parse_elements( $2 )
+        end
+      end
+
+      case type
+      when /\Avarchar/
+        return :string, :default_size => 255
+      when /\Achar/
+        return :string, :fixed => true, :default_size => 255
+      when /\Atext\z/
+        return :string, :text => true
+      when /\A(\w+)\([\s\d,]+\)\z/
+        return $1.to_sym
+      when /\A\w+\z/
+        return type
+      end
+
+      ruby_type
+    end
+
+    # Convert given database type to type and optional options used by our schema definitions.
+    # The ruby type provided serves as a hint of what Sequel's idea of the type is.
+    def revert_type_literal( type, ruby_type )
+
+      case type
+      when /\(\s*(\d+)\s*\)/
+        size = $1.to_i
+      when /\(([\s\d,]+)\)/
+        size = $1.split( ',' ).map{ |x| x.to_i }
+      end
+
+      type, opts = revert_type_literal_internal( type, ruby_type )
+
+      opts ||= {}
+
+      default_size = opts.delete( :default_size )
+
+      if size and size != default_size
+        opts[ :size ] = size
+      end
+
+      [ type, opts ]
+    end
+
+    # Import indexes of given table.
+    def import_indexes( table )
+      # Foreign keys also automatically create indexes, which we must exclude when importing.
+      # But only if they look like indexes named by the automatic foreign key naming convention.
+      foreign_key_indexes = table.foreign_keys.map{ |x| x.columns if x.columns.size == 1 }.compact
+      for name, opts in db.indexes( table.name )
+        opts = opts.dup
+        columns = opts.delete( :columns )
+        next if ( ! opts[ :unique ] ) && foreign_key_indexes.include?( columns ) && name == columns.first
+        table.add_index( columns, opts )
+      end
+    end
+
+    # Import foreign keys of given table.
+    def import_foreign_keys( table )
+      for opts in db.foreign_key_list( table.name )
+        opts = opts.dup
+        name = opts.delete( :name )
+        columns = opts.delete( :columns )
+        table_name = opts.delete( :table )
+        table.add_foreign_key( columns, table_name, opts )
+      end
+    end
+
+    # Our custom mapping of some database defaults into the values we use in our schemas.
+    DEFAULT_CONSTANTS = {
+      "0000-00-00 00:00:00" => 0,
+      "CURRENT_TIMESTAMP" => Sequel.lit("CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"),
+    }
+
+    # Options which are ignored for columns.
+    # These are usually just schema hints which the user normally doesn't specify.
+    IGNORED_OPTS = [ :max_length ]
+
+    # Import columns of given table.
+    def import_columns( table )
+      schema = db.schema( table.name )
+
+      # Get info about primary key columns.
+
+      primary_key_columns = schema.select{ |name, opts| opts[ :primary_key ] }
+
+      multi_primary_key =  ( primary_key_columns.count > 1 )
+
+      # Import each column in sequence.
+
+      for name, opts in schema
+
+        opts = opts.dup
+
+        # Discard anything we don't need.
+
+        opts.delete_if{ |key, value| IGNORED_OPTS.include? key }
+
+        # Import type.
+
+        type = opts.delete( :type )
+        db_type = opts.delete( :db_type )
+
+        type, type_opts = revert_type_literal( db_type, type )
+        opts.merge!( type_opts ) if type_opts
+
+        # Import NULL option.
+
+        opts[ :null ] = opts.delete( :allow_null )
+
+        # Import default value.
+
+        default = opts.delete( :default )
+        ruby_default = opts.delete( :ruby_default )
+
+        default = DEFAULT_CONSTANTS[ default ] || ( ruby_default.nil? ? default : ruby_default )
+
+        unless default.nil?
+          opts[ :default ] = default
+        end
+
+        # Deal with primary keys, which is a bit obscure because of the auto-increment handling.
+
+        primary_key = opts.delete( :primary_key )
+        auto_increment = opts.delete( :auto_increment )
+
+        if primary_key && ! multi_primary_key
+          if auto_increment
+            table.add_column( :primary_key, name, opts.merge( :type => type ) )
+            next
+          end
+          opts[ :primary_key ] = primary_key
+        end
+
+        table.add_column( type, name, opts )
+      end
+
+      # Define multi-column primary key if necessary.
+      # Note that Sequel currently doesn't preserve the primary key order, so neither can we.
+
+      if multi_primary_key
+        table.add_column( :primary_key, primary_key_columns.map{ |name, opts| name } )
+      end
+    end
+
+    # Import all fields of given table.
+    def import_table( table )
+      # This must come first, so we can exclude foreign key indexes later.
+      import_foreign_keys( table )
+      import_indexes( table )
+      import_columns( table )
+    end
+
+    public
+
+    # Which tables we automatically ignore on import.
+    IGNORED_TABLES = [ :schema_info ]
+
+    # Import the database schema.
+    def schema
+      schema = Schema.new
+
+      for name in db.tables
+        next if IGNORED_TABLES.include? name
+        table = schema.add_table( name )
+        import_table( table )
+      end
+
+      schema
+    end
+
+  end
+
+end
+
+# EOF #