asana2flowdock 1.0.0

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/extensions/query_literals.rb

@@ -0,0 +1,80 @@
+# The query_literals extension changes Sequel's default behavior of
+# the select, order and group methods so that if the first argument
+# is a regular string, it is treated as a literal string, with the
+# rest of the arguments (if any) treated as placeholder values. This
+# allows you to write code such as:
+#
+#   DB[:table].select('a, b, ?', 2).group('a, b').order('c')
+#
+# The default Sequel behavior would literalize that as:
+#
+#   SELECT 'a, b, ?', 2 FROM table GROUP BY 'a, b' ORDER BY 'c'
+#
+# Using this extension changes the literalization to:
+#
+#   SELECT a, b, 2, FROM table GROUP BY a, b ORDER BY c
+#
+# This extension makes select, group, and order methods operate
+# like filter methods, which support the same interface.
+#
+# There are very few places where Sequel's default behavior is
+# desirable in this area, but for backwards compatibility, the
+# defaults won't be changed until the next major release.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:query_literals)
+#
+# Or you can load it into all of a database's datasets, which
+# is probably the desired behavior if you are using this extension:
+#
+#   DB.extension(:query_literals)
+
+#
+module Sequel
+  # The QueryLiterals module can be used to make select, group, and
+  # order methods operate similar to the filter methods if the first
+  # argument is a plain string, treating it like a literal string,
+  # with any remaining arguments treated as placeholder values.
+  #
+  # This adds such support to the following methods: select, select_append,
+  # select_group, select_more, group, group_and_count, order, order_append,
+  # and order_more.
+  #
+  # Note that if you pass a block to these methods, it will use the default
+  # implementation without the special literal handling.
+  module QueryLiterals
+    %w'select select_append select_group select_more group group_and_count order order_append order_more'.each do |m|
+      class_eval(<<-END, __FILE__, __LINE__ + 1)
+        def #{m}(*args)
+          if !block_given? && (l = query_literal(args))
+            super(l)
+          else
+            super
+          end
+        end
+      END
+    end
+
+    private
+
+    # If the first argument is a plain string, return a literal string
+    # if there are no additional args or a placeholder literal string with
+    # the remaining args.  Otherwise, return nil.
+    def query_literal(args)
+      case (s = args[0])
+      when LiteralString, SQL::Blob
+        nil
+      when String
+        if args.length == 1
+          LiteralString.new(s)
+        else
+          SQL::PlaceholderLiteralString.new(s, args[1..-1])
+        end
+      end
+    end
+  end
+
+  Dataset.register_extension(:query_literals, QueryLiterals)
+end

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/extensions/round_timestamps.rb

@@ -0,0 +1,52 @@
+# The round_timestamps extension will automatically round timestamp
+# values to the database's supported level of precision before literalizing
+# them.
+#
+# For example, if the database supports microsecond precision, and you give
+# it a Time value with greater than microsecond precision, it will round it
+# appropriately:
+#
+#   Time.at(1405341161.917999982833862)
+#   # default: 2014-07-14 14:32:41.917999
+#   # with extension: 2014-07-14 14:32:41.918000
+#
+# The round_timestamps extension correctly deals with databases that support
+# millisecond or second precision.  In addition to handling Time values, it
+# also handles DateTime values and Sequel::SQLTime values (for the TIME type).
+#
+# To round timestamps for a single dataset:
+#
+#   ds = ds.extension(:round_timestamps)
+#
+# To round timestamps for all datasets on a single database:
+#
+#   DB.extension(:round_timestamps)
+
+unless RUBY_VERSION >= '1.9'
+  # :nocov:
+  raise LoadError, 'the round_timestamps extension only works on ruby 1.9+'
+  # :nocov:
+end
+
+module Sequel
+  class Dataset
+    module RoundTimestamps
+      # Round DateTime values before literalizing
+      def literal_datetime(v)
+        super(v + Rational(5, 10**timestamp_precision)/864000)
+      end
+
+      # Round Sequel::SQLTime values before literalizing
+      def literal_sqltime(v)
+        super(v.round(timestamp_precision))
+      end
+
+      # Round Time values before literalizing
+      def literal_time(v)
+        super(v.round(timestamp_precision))
+      end
+    end
+
+    register_extension(:round_timestamps, RoundTimestamps)
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/extensions/ruby18_symbol_extensions.rb

@@ -0,0 +1,22 @@
+# The ruby18_symbol_extensions adds the <, <=, >, >= to Symbol
+# to reflect the mathmatical operators.  It also adds the [] method
+# to Symbol for creating SQL functions.
+#
+# Usage of this extension is not recommended. This extension will
+# only load on ruby 1.8, so you will not be able to upgrade to
+# newer ruby versions if you use it. If you still want to use it,
+# you can load it via:
+#
+#   Sequel.extension :ruby18_symbol_extensions
+
+raise(Sequel::Error, "The ruby18_symbol_extensions is only available on ruby 1.8.") unless RUBY_VERSION < '1.9.0'
+
+class Symbol
+  include Sequel::SQL::InequalityMethods
+
+  # Create an SQL Function with the receiver as the function name
+  # and the given arguments.
+  def [](*args)
+    Sequel::SQL::Function.new(self, *args)
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/extensions/schema_caching.rb

@@ -0,0 +1,75 @@
+# The schema_caching extension adds a few methods to Sequel::Database
+# that make it easy to dump the parsed schema information to a file,
+# and load it from that file.  Loading the schema information from a
+# dumped file is faster than parsing it from the database, so this
+# can save bootup time for applications with large numbers of models.
+#
+# Basic usage in application code:
+#
+#   DB = Sequel.connect('...')
+#   DB.extension :schema_caching
+#   DB.load_schema_cache('/path/to/schema.dump')
+#
+#   # load model files
+#
+# Then, whenever the database schema is modified, write a new cached
+# file.  You can do that with <tt>bin/sequel</tt>'s -S option:
+#
+#   bin/sequel -S /path/to/schema.dump postgres://...
+#
+# Alternatively, if you don't want to dump the schema information for
+# all tables, and you don't worry about race conditions, you can
+# choose to use the following in your application code:
+#
+#   DB = Sequel.connect('...')
+#   DB.extension :schema_caching
+#   DB.load_schema_cache?('/path/to/schema.dump')
+#
+#   # load model files
+#
+#   DB.dump_schema_cache?('/path/to/schema.dump')
+#
+# With this method, you just have to delete the schema dump file if
+# the schema is modified, and the application will recreate it for you
+# using just the tables that your models use.
+#
+# Note that it is up to the application to ensure that the dumped
+# cached schema reflects the current state of the database.  Sequel
+# does no checking to ensure this, as checking would take time and the
+# purpose of this code is to take a shortcut.
+#
+# The cached schema is dumped in Marshal format, since it is the fastest
+# and it handles all ruby objects used in the schema hash.  Because of this,
+# you should not attempt to load the schema from a untrusted file.
+
+#
+module Sequel
+  module SchemaCaching
+    # Dump the cached schema to the filename given in Marshal format.
+    def dump_schema_cache(file)
+      File.open(file, 'wb'){|f| f.write(Marshal.dump(@schemas))}
+      nil
+    end
+
+    # Dump the cached schema to the filename given unless the file
+    # already exists.
+    def dump_schema_cache?(file)
+      dump_schema_cache(file) unless File.exist?(file)
+    end
+
+    # Replace the schema cache with the data from the given file, which
+    # should be in Marshal format.
+    def load_schema_cache(file)
+      @schemas = Marshal.load(File.read(file))
+      nil
+    end
+
+    # Replace the schema cache with the data from the given file if the
+    # file exists.
+    def load_schema_cache?(file)
+      load_schema_cache(file) if File.exist?(file)
+    end
+  end
+
+  Database.register_extension(:schema_caching, SchemaCaching)
+end

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/extensions/schema_dumper.rb

@@ -0,0 +1,476 @@
+# The schema_dumper extension supports dumping tables and indexes
+# in a Sequel::Migration format, so they can be restored on another
+# database (which can be the same type or a different type than
+# the current database).  The main interface is through
+# Sequel::Database#dump_schema_migration.
+#
+# To load the extension:
+#
+#   DB.extension :schema_dumper
+
+Sequel.extension :eval_inspect
+
+module Sequel
+  module SchemaDumper
+    # Convert the column schema information to a hash of column options, one of which must
+    # be :type.  The other options added should modify that type (e.g. :size).  If a
+    # database type is not recognized, return it as a String type.
+    def column_schema_to_ruby_type(schema)
+      case schema[:db_type].downcase
+      when /\A(medium|small)?int(?:eger)?(?:\((\d+)\))?( unsigned)?\z/o
+        if !$1 && $2 && $2.to_i >= 10 && $3
+          # Unsigned integer type with 10 digits can potentially contain values which
+          # don't fit signed integer type, so use bigint type in target database.
+          {:type=>Bignum}
+        else
+          {:type=>Integer}
+        end
+      when /\Atinyint(?:\((\d+)\))?(?: unsigned)?\z/o
+        {:type =>schema[:type] == :boolean ? TrueClass : Integer}
+      when /\Abigint(?:\((?:\d+)\))?(?: unsigned)?\z/o
+        {:type=>Bignum}
+      when /\A(?:real|float|double(?: precision)?|double\(\d+,\d+\)(?: unsigned)?)\z/o
+        {:type=>Float}
+      when 'boolean'
+        {:type=>TrueClass}
+      when /\A(?:(?:tiny|medium|long|n)?text|clob)\z/o
+        {:type=>String, :text=>true}
+      when 'date'
+        {:type=>Date}
+      when /\A(?:small)?datetime\z/o
+        {:type=>DateTime}
+      when /\Atimestamp(?:\((\d+)\))?(?: with(?:out)? time zone)?\z/o
+        {:type=>DateTime, :size=>($1.to_i if $1)}
+      when /\Atime(?: with(?:out)? time zone)?\z/o
+        {:type=>Time, :only_time=>true}
+      when /\An?char(?:acter)?(?:\((\d+)\))?\z/o
+        {:type=>String, :size=>($1.to_i if $1), :fixed=>true}
+      when /\A(?:n?varchar|character varying|bpchar|string)(?:\((\d+)\))?\z/o
+        {:type=>String, :size=>($1.to_i if $1)}
+      when /\A(?:small)?money\z/o
+        {:type=>BigDecimal, :size=>[19,2]}
+      when /\A(?:decimal|numeric|number)(?:\((\d+)(?:,\s*(\d+))?\))?\z/o
+        s = [($1.to_i if $1), ($2.to_i if $2)].compact
+        {:type=>BigDecimal, :size=>(s.empty? ? nil : s)}
+      when /\A(?:bytea|(?:tiny|medium|long)?blob|(?:var)?binary)(?:\((\d+)\))?\z/o
+        {:type=>File, :size=>($1.to_i if $1)}
+      when /\A(?:year|(?:int )?identity)\z/o
+        {:type=>Integer}
+      else
+        {:type=>String}
+      end
+    end
+
+    # Dump foreign key constraints for all tables as a migration. This complements
+    # the :foreign_keys=>false option to dump_schema_migration. This only dumps
+    # the constraints (not the columns) using alter_table/add_foreign_key with an
+    # array of columns.
+    #
+    # Note that the migration this produces does not have a down
+    # block, so you cannot reverse it.
+    def dump_foreign_key_migration(options=OPTS)
+      ts = tables(options)
+      <<END_MIG
+Sequel.migration do
+  change do
+#{ts.sort_by{|t| t.to_s}.map{|t| dump_table_foreign_keys(t)}.reject{|x| x == ''}.join("\n\n").gsub(/^/o, '    ')}
+  end
+end
+END_MIG
+    end
+
+    # Dump indexes for all tables as a migration.  This complements
+    # the :indexes=>false option to dump_schema_migration. Options:
+    # :same_db :: Create a dump for the same database type, so
+    #             don't ignore errors if the index statements fail.
+    # :index_names :: If set to false, don't record names of indexes. If
+    #                 set to :namespace, prepend the table name to the index name if the
+    #                 database does not use a global index namespace.
+    def dump_indexes_migration(options=OPTS)
+      ts = tables(options)
+      <<END_MIG
+Sequel.migration do
+  change do
+#{ts.sort_by{|t| t.to_s}.map{|t| dump_table_indexes(t, :add_index, options)}.reject{|x| x == ''}.join("\n\n").gsub(/^/o, '    ')}
+  end
+end
+END_MIG
+    end
+
+    # Return a string that contains a Sequel::Migration subclass that when
+    # run would recreate the database structure. Options:
+    # :same_db :: Don't attempt to translate database types to ruby types.
+    #             If this isn't set to true, all database types will be translated to
+    #             ruby types, but there is no guarantee that the migration generated
+    #             will yield the same type.  Without this set, types that aren't
+    #             recognized will be translated to a string-like type.
+    # :foreign_keys :: If set to false, don't dump foreign_keys (they can be
+    #                  added later via #dump_foreign_key_migration)
+    # :indexes :: If set to false, don't dump indexes (they can be added
+    #             later via #dump_index_migration).
+    # :index_names :: If set to false, don't record names of indexes. If
+    #                 set to :namespace, prepend the table name to the index name.
+    def dump_schema_migration(options=OPTS)
+      options = options.dup
+      if options[:indexes] == false && !options.has_key?(:foreign_keys)
+        # Unless foreign_keys option is specifically set, disable if indexes
+        # are disabled, as foreign keys that point to non-primary keys rely
+        # on unique indexes being created first
+        options[:foreign_keys] = false
+      end
+
+      ts = sort_dumped_tables(tables(options), options)
+      skipped_fks = if sfk = options[:skipped_foreign_keys]
+        # Handle skipped foreign keys by adding them at the end via
+        # alter_table/add_foreign_key.  Note that skipped foreign keys
+        # probably result in a broken down migration.
+        sfka = sfk.sort_by{|table, fks| table.to_s}.map{|table, fks| dump_add_fk_constraints(table, fks.values)}
+        sfka.join("\n\n").gsub(/^/o, '    ') unless sfka.empty?
+      end
+
+      <<END_MIG
+Sequel.migration do
+  change do
+#{ts.map{|t| dump_table_schema(t, options)}.join("\n\n").gsub(/^/o, '    ')}#{"\n    \n" if skipped_fks}#{skipped_fks}
+  end
+end
+END_MIG
+    end
+
+    # Return a string with a create table block that will recreate the given
+    # table's schema.  Takes the same options as dump_schema_migration.
+    def dump_table_schema(table, options=OPTS)
+      table = table.value.to_s if table.is_a?(SQL::Identifier)
+      gen = dump_table_generator(table, options)
+      commands = [gen.dump_columns, gen.dump_constraints, gen.dump_indexes].reject{|x| x == ''}.join("\n\n")
+      "create_table(#{table.inspect}#{', :ignore_index_errors=>true' if !options[:same_db] && options[:indexes] != false && !gen.indexes.empty?}) do\n#{commands.gsub(/^/o, '  ')}\nend"
+    end
+
+    private
+        
+    # If a database default exists and can't be converted, and we are dumping with :same_db,
+    # return a string with the inspect method modified a literal string is created if the code is evaled.  
+    def column_schema_to_ruby_default_fallback(default, options)
+      if default.is_a?(String) && options[:same_db] && use_column_schema_to_ruby_default_fallback?
+        default = default.dup
+        def default.inspect
+          "Sequel::LiteralString.new(#{super})"
+        end
+        default
+      end
+    end
+
+    # Recreate the column in the passed Schema::Generator from the given name and parsed database schema.
+    def recreate_column(name, schema, gen, options)
+      if options[:single_pk] && schema_autoincrementing_primary_key?(schema)
+        type_hash = options[:same_db] ? {:type=>schema[:db_type]} : column_schema_to_ruby_type(schema)
+        [:table, :key, :on_delete, :on_update, :deferrable].each{|f| type_hash[f] = schema[f] if schema[f]}
+        if type_hash == {:type=>Integer} || type_hash == {:type=>"integer"}
+          gen.primary_key(name)
+        else
+          gen.primary_key(name, type_hash)
+        end
+      else
+        col_opts = if options[:same_db]
+          h = {:type=>schema[:db_type]}
+          if database_type == :mysql && h[:type] =~ /\Atimestamp/
+            h[:null] = true
+          end
+          h
+        else
+          column_schema_to_ruby_type(schema)
+        end
+        type = col_opts.delete(:type)
+        col_opts.delete(:size) if col_opts[:size].nil?
+        col_opts[:default] = if schema[:ruby_default].nil?
+          column_schema_to_ruby_default_fallback(schema[:default], options)
+        else
+          schema[:ruby_default]
+        end
+        col_opts.delete(:default) if col_opts[:default].nil?
+        col_opts[:null] = false if schema[:allow_null] == false
+        if table = schema[:table]
+          [:key, :on_delete, :on_update, :deferrable].each{|f| col_opts[f] = schema[f] if schema[f]}
+          col_opts[:type] = type unless type == Integer || type == 'integer'
+          gen.foreign_key(name, table, col_opts)
+        else
+          gen.column(name, type, col_opts)
+          if [Integer, Bignum, Float].include?(type) && schema[:db_type] =~ / unsigned\z/io
+            gen.check(Sequel::SQL::Identifier.new(name) >= 0)
+          end
+        end
+      end
+    end
+
+    # For the table and foreign key metadata array, return an alter_table
+    # string that would add the foreign keys if run in a migration.
+    def dump_add_fk_constraints(table, fks)
+      sfks = "alter_table(#{table.inspect}) do\n"
+      sfks << create_table_generator do
+        fks.sort_by{|fk| fk[:columns].map{|c| c.to_s}}.each do |fk|
+          foreign_key fk[:columns], fk
+        end
+      end.dump_constraints.gsub(/^foreign_key /, '  add_foreign_key ')
+      sfks << "\nend"
+    end
+
+    # For the table given, get the list of foreign keys and return an alter_table
+    # string that would add the foreign keys if run in a migration.
+    def dump_table_foreign_keys(table, options=OPTS)
+      if supports_foreign_key_parsing?
+        fks = foreign_key_list(table, options).sort_by{|fk| fk[:columns].map{|c| c.to_s}}
+      end
+
+      if fks.nil? || fks.empty?
+        ''
+      else
+        dump_add_fk_constraints(table, fks)
+      end
+    end
+
+    # Return a Schema::Generator object that will recreate the
+    # table's schema.  Takes the same options as dump_schema_migration.
+    def dump_table_generator(table, options=OPTS)
+      table = table.value.to_s if table.is_a?(SQL::Identifier)
+      raise(Error, "must provide table as a Symbol, String, or Sequel::SQL::Identifier") unless [String, Symbol].any?{|c| table.is_a?(c)}
+      s = schema(table).dup
+      pks = s.find_all{|x| x.last[:primary_key] == true}.map{|x| x.first}
+      options = options.merge(:single_pk=>true) if pks.length == 1
+      m = method(:recreate_column)
+      im = method(:index_to_generator_opts)
+
+      if options[:indexes] != false && supports_index_parsing?
+        indexes = indexes(table).sort_by{|k,v| k.to_s}
+      end
+
+      if options[:foreign_keys] != false && supports_foreign_key_parsing?
+        fk_list = foreign_key_list(table)
+        
+        if (sfk = options[:skipped_foreign_keys]) && (sfkt = sfk[table])
+          fk_list.delete_if{|fk| sfkt.has_key?(fk[:columns])}
+        end
+
+        composite_fks, single_fks = fk_list.partition{|h| h[:columns].length > 1}
+        fk_hash = {}
+
+        single_fks.each do |fk|
+          column = fk.delete(:columns).first
+          fk.delete(:name)
+          fk_hash[column] = fk
+        end
+
+        s = s.map do |name, info|
+          if fk_info = fk_hash[name]
+            [name, fk_info.merge(info)]
+          else
+            [name, info]
+          end
+        end
+      end
+
+      create_table_generator do
+        s.each{|name, info| m.call(name, info, self, options)}
+        primary_key(pks) if !@primary_key && pks.length > 0
+        indexes.each{|iname, iopts| send(:index, iopts[:columns], im.call(table, iname, iopts, options))} if indexes
+        composite_fks.each{|fk| send(:foreign_key, fk[:columns], fk)} if composite_fks
+      end
+    end
+
+    # Return a string that containing add_index/drop_index method calls for
+    # creating the index migration.
+    def dump_table_indexes(table, meth, options=OPTS)
+      if supports_index_parsing?
+        indexes = indexes(table).sort_by{|k,v| k.to_s}
+      else
+        return ''
+      end
+
+      im = method(:index_to_generator_opts)
+      gen = create_table_generator do
+        indexes.each{|iname, iopts| send(:index, iopts[:columns], im.call(table, iname, iopts, options))}
+      end
+      gen.dump_indexes(meth=>table, :ignore_errors=>!options[:same_db])
+    end
+
+    # Convert the parsed index information into options to the Generators index method. 
+    def index_to_generator_opts(table, name, index_opts, options=OPTS)
+      h = {}
+      if options[:index_names] != false && default_index_name(table, index_opts[:columns]) != name.to_s
+        if options[:index_names] == :namespace && !global_index_namespace?
+          h[:name] = "#{table}_#{name}".to_sym
+        else
+          h[:name] = name
+        end
+      end
+      h[:unique] = true if index_opts[:unique]
+      h[:deferrable] = true if index_opts[:deferrable]
+      h
+    end
+
+    # Sort the tables so that referenced tables are created before tables that
+    # reference them, and then by name.  If foreign keys are disabled, just sort by name.
+    def sort_dumped_tables(tables, options=OPTS)
+      if options[:foreign_keys] != false && supports_foreign_key_parsing?
+        table_fks = {}
+        tables.each{|t| table_fks[t] = foreign_key_list(t)}
+        # Remove self referential foreign keys, not important when sorting.
+        table_fks.each{|t, fks| fks.delete_if{|fk| fk[:table] == t}}
+        tables, skipped_foreign_keys = sort_dumped_tables_topologically(table_fks, [])
+        options[:skipped_foreign_keys] = skipped_foreign_keys
+        tables
+      else
+        tables.sort_by{|t| t.to_s}
+      end
+    end
+
+    # Do a topological sort of tables, so that referenced tables
+    # come before referencing tables.  Returns an array of sorted
+    # tables and a hash of skipped foreign keys.  The hash will be
+    # empty unless there are circular dependencies.
+    def sort_dumped_tables_topologically(table_fks, sorted_tables)
+      skipped_foreign_keys = {}
+
+      until table_fks.empty? 
+        this_loop = []
+
+        table_fks.each do |table, fks|
+          fks.delete_if{|fk| !table_fks.has_key?(fk[:table])}
+          this_loop << table if fks.empty?
+        end
+
+        if this_loop.empty?
+          # No tables were changed this round, there must be a circular dependency.
+          # Break circular dependency by picking the table with the least number of
+          # outstanding foreign keys and skipping those foreign keys.
+          # The skipped foreign keys will be added at the end of the
+          # migration.
+          skip_table, skip_fks = table_fks.sort_by{|table, fks| [fks.length, table.to_s]}.first
+          skip_fks_hash = skipped_foreign_keys[skip_table] = {}
+          skip_fks.each{|fk| skip_fks_hash[fk[:columns]] = fk}
+          this_loop << skip_table
+        end
+
+        # Add sorted tables from this loop to the final list
+        sorted_tables.concat(this_loop.sort_by{|t| t.to_s})
+
+        # Remove tables that were handled this loop
+        this_loop.each{|t| table_fks.delete(t)}
+      end
+
+      [sorted_tables, skipped_foreign_keys]
+    end
+    
+    # Don't use a literal string fallback on MySQL, since the defaults it uses aren't
+    # valid literal SQL values.
+    def use_column_schema_to_ruby_default_fallback?
+      database_type != :mysql
+    end
+  end
+
+  module Schema
+    class Generator
+      # Dump this generator's columns to a string that could be evaled inside
+      # another instance to represent the same columns
+      def dump_columns
+        strings = []
+        cols = columns.dup
+        cols.each do |x|
+          x.delete(:on_delete) if x[:on_delete] == :no_action
+          x.delete(:on_update) if x[:on_update] == :no_action
+        end
+        if pkn = primary_key_name
+          cols.delete_if{|x| x[:name] == pkn}
+          pk = @primary_key.dup
+          pkname = pk.delete(:name)
+          @db.serial_primary_key_options.each{|k,v| pk.delete(k) if v == pk[k]}
+          strings << "primary_key #{pkname.inspect}#{opts_inspect(pk)}"
+        end
+        cols.each do |c|
+          c = c.dup
+          name = c.delete(:name)
+          strings << if table = c.delete(:table)
+            c.delete(:type) if c[:type] == Integer || c[:type] == 'integer'
+            "foreign_key #{name.inspect}, #{table.inspect}#{opts_inspect(c)}"
+          else
+            type = c.delete(:type)
+            opts = opts_inspect(c)
+            if type.is_a?(Class)
+              "#{type.name} #{name.inspect}#{opts}"
+            else
+              "column #{name.inspect}, #{type.inspect}#{opts}"
+            end
+          end
+        end
+        strings.join("\n")
+      end
+
+      # Dump this generator's constraints to a string that could be evaled inside
+      # another instance to represent the same constraints
+      def dump_constraints
+        cs = constraints.map do |c|
+          c = c.dup
+          type = c.delete(:type)
+          case type
+          when :check
+            raise(Error, "can't dump check/constraint specified with Proc") if c[:check].is_a?(Proc)
+            name = c.delete(:name)
+            if !name and c[:check].length == 1 and c[:check].first.is_a?(Hash)
+              "check #{c[:check].first.inspect[1...-1]}"
+            else
+              "#{name ? "constraint #{name.inspect}," : 'check'} #{c[:check].map{|x| x.inspect}.join(', ')}"
+            end
+          when :foreign_key
+            c.delete(:on_delete) if c[:on_delete] == :no_action
+            c.delete(:on_update) if c[:on_update] == :no_action
+            c.delete(:deferrable) unless c[:deferrable]
+            cols = c.delete(:columns)
+            table = c.delete(:table)
+            "#{type} #{cols.inspect}, #{table.inspect}#{opts_inspect(c)}"
+          else
+            cols = c.delete(:columns)
+            "#{type} #{cols.inspect}#{opts_inspect(c)}"
+          end
+        end
+        cs.join("\n")
+      end
+
+      # Dump this generator's indexes to a string that could be evaled inside
+      # another instance to represent the same indexes. Options:
+      # * :add_index - Use add_index instead of index, so the methods
+      #   can be called outside of a generator but inside a migration.
+      #   The value of this option should be the table name to use.
+      # * :drop_index - Same as add_index, but create drop_index statements.
+      # * :ignore_errors - Add the ignore_errors option to the outputted indexes
+      def dump_indexes(options=OPTS)
+        is = indexes.map do |c|
+          c = c.dup
+          cols = c.delete(:columns)
+          if table = options[:add_index] || options[:drop_index]
+            "#{options[:drop_index] ? 'drop' : 'add'}_index #{table.inspect}, #{cols.inspect}#{', :ignore_errors=>true' if options[:ignore_errors]}#{opts_inspect(c)}"
+          else
+            "index #{cols.inspect}#{opts_inspect(c)}"
+          end
+        end
+        is = is.reverse if options[:drop_index]
+        is.join("\n")
+      end
+
+      private
+
+      # Return a string that converts the given options into one
+      # suitable for literal ruby code, handling default values
+      # that don't default to a literal interpretation.
+      def opts_inspect(opts)
+        if opts[:default]
+          opts = opts.dup
+          de = Sequel.eval_inspect(opts.delete(:default)) 
+          ", :default=>#{de}#{", #{opts.inspect[1...-1]}" if opts.length > 0}"
+        else
+          ", #{opts.inspect[1...-1]}" if opts.length > 0
+        end
+      end
+    end
+  end
+
+  Database.register_extension(:schema_dumper, SchemaDumper)
+end