numeric_type_column 0.0.1 → 0.0.2

data/Rakefile

@@ -20,6 +20,8 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
 
 
 

data/lib/numeric_type_column/active_record/{base_extension.rb → base_patch.rb}

@@ -4,7 +4,7 @@ module NumericTypeColumn
 
   module ActiveRecord
     
-    module BaseExtension
+    module BasePatch
       
       # http://yehudakatz.com/2009/11/12/better-ruby-idioms/
           
@@ -24,7 +24,7 @@ module NumericTypeColumn
         
         # ActiveRecord::Inheritance::ClassMethods#find_sti_class
         def find_sti_class(type_id)
-          puts "(MonkeyPatch) NumericTypeColumn::ActiveRecord::BaseExtension: find_sti_class(type_id: #{type_id} )... #{base_class.inheritance_map.inspect}"
+          # puts "(MonkeyPatch) NumericTypeColumn::ActiveRecord::BasePatch: find_sti_class(type_id: #{type_id} )... #{base_class.inheritance_map.inspect}"
           base_class.inheritance_map[type_id].constantize
         end
         
@@ -61,7 +61,7 @@ module NumericTypeColumn
           # Setear el atributo de inheritance_column:
           send("#{self.class.inheritance_column.to_sym}=", self.class.base_class.inheritance_map.key(self.class.sti_name))
           
-          raise ReadOnlyRecord if readonly?
+          raise ActiveRecord::ReadOnlyRecord if readonly?
           result = new_record? ? create : update
           result != false
         end

data/lib/numeric_type_column/active_record/{belongs_to_polymorphic_association_extension.rb → belongs_to_polymorphic_association_patch.rb}

@@ -3,17 +3,17 @@
 module NumericTypeColumn
   module ActiveRecord
     
-    module BelongsToPolymorphicAssociationExtension
+    module BelongsToPolymorphicAssociationPatch
     
       def self.included(base)
-        #puts "NumericTypeColumn::ActiveRecord::BelongsToPolymorphicAssociationExtension included to #{base.name}!"
+        #puts "NumericTypeColumn::ActiveRecord::BelongsToPolymorphicAssociationPatch included to #{base.name}!"
         base.send :alias_method_chain, :klass,        :numeric_type_column
         base.send :alias_method_chain, :replace_keys, :numeric_type_column
       end
     
       def klass_with_numeric_type_column
       
-        #puts "NumericTypeColumn::ActiveRecord::BelongsToPolymorphicAssociationExtension: klass_with_numeric_type_column"
+        #puts "NumericTypeColumn::ActiveRecord::BelongsToPolymorphicAssociationPatch: klass_with_numeric_type_column"
       
         type = owner[reflection.foreign_type]
         
@@ -27,7 +27,7 @@ module NumericTypeColumn
 
       def replace_keys_with_numeric_type_column(record)
       
-        #puts "NumericTypeColumn::ActiveRecord::BelongsToPolymorphicAssociationExtension: replace_keys_with_numeric_type_column(record: #{record})"
+        #puts "NumericTypeColumn::ActiveRecord::BelongsToPolymorphicAssociationPatch: replace_keys_with_numeric_type_column(record: #{record})"
       
         super
         if owner.attribute_names.include?(reflection.foreign_type)

data/lib/numeric_type_column/active_record/{column_definition_extension.rb → column_definition_patch.rb}

@@ -6,19 +6,19 @@ module NumericTypeColumn
   module ActiveRecord
   
     # Basado en http://thewebfellas.com/blog/2008/6/2/unsigned-integers-for-mysql-on-rails
-    module ColumnDefinitionExtension
+    module ColumnDefinitionPatch
     
       attr_accessor :unsigned, :comment
       
       def self.included(base)
-        #puts "NumericTypeColumn::ActiveRecord::ColumnDefinitionExtension included to #{base.name}!"
+        #puts "NumericTypeColumn::ActiveRecord::ColumnDefinitionPatch included to #{base.name}!"
         base.send :alias_method_chain, :sql_type, :unsigned
         base.send :alias_method_chain, :to_sql,   :extra_options
       end
 
       # Override de #sql_type
       def sql_type_with_unsigned
-        #puts "NumericTypeColumn::ActiveRecord::ColumnDefinitionExtension: sql_type_with_unsigned"
+        #puts "NumericTypeColumn::ActiveRecord::ColumnDefinitionPatch: sql_type_with_unsigned"
         # Cambio: signature de call base.type_to_sql:
         if base.method(:type_to_sql).parameters.include?([:opt, :unsigned])
           base.type_to_sql(type.to_sym, limit, precision, scale, unsigned) rescue type
@@ -30,7 +30,7 @@ module NumericTypeColumn
       
       # Override de #to_sql
       def to_sql_with_extra_options
-        #puts "NumericTypeColumn::ActiveRecord::ColumnDefinitionExtension: to_sql_with_extra_options"
+        #puts "NumericTypeColumn::ActiveRecord::ColumnDefinitionPatch: to_sql_with_extra_options"
         column_sql = "#{base.quote_column_name(name)} #{sql_type}"
         column_options = {}
         column_options[:null] = null unless null.nil?

data/lib/numeric_type_column/active_record/mysql_adapter_patch.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+
+module NumericTypeColumn
+
+  module ActiveRecord
+    
+    module MysqlColumnPatch  
+    
+      def self.included(base)
+        #puts "NumericTypeColumn::ActiveRecord::MysqlColumnPatch included to #{base.name}!"
+        base.send :alias_method_chain, :initialize,  :comment
+      end
+      
+      attr_reader :comment
+      
+      def initialize_with_comment(name, default, sql_type = nil, null = true, collation = nil, comment = nil)
+        # puts "NumericTypeColumn::ActiveRecord::MysqlColumnPatch#initialize_with_comment - comment: #{comment}"
+        initialize_without_comment(name, default, sql_type, null, collation)
+        @comment = comment if comment.present?
+      end
+      
+    end
+  
+    module MysqlAdapterPatch  
+    
+      def self.included(base)
+        #puts "NumericTypeColumn::ActiveRecord::MysqlAdapterPatch included to #{base.name}!"
+        base::NATIVE_DATABASE_TYPES[:primary_key] = 'INT UNSIGNED DEFAULT NULL auto_increment PRIMARY KEY'
+        base.send :alias_method_chain, :add_column_sql,       :unsigned
+        base.send :alias_method_chain, :type_to_sql,          :unsigned
+        base.send :alias_method_chain, :add_column_options!,  :comment
+        base.send :alias_method_chain, :columns,              :comment
+        base.send :alias_method_chain, :new_column,           :comment
+        #base.send :alias_method_chain, :create_table,         :mysql_options
+        
+        # Incluir patch a self::Column:
+        "#{base.name}::Column".constantize.send :include, NumericTypeColumn::ActiveRecord::MysqlColumnPatch
+      end
+
+=begin
+      def create_table_with_mysql_options(table_name, options = {}) #:nodoc:
+        puts "NumericTypeColumn::ActiveRecord::MysqlAdapterPatch: create_table(table_name: #{table_name}, options: #{options})"
+        create_table_without_mysql_options(table_name, options.reverse_merge(options: options[:mysql_options] ? options[:mysql_options] : "ENGINE=InnoDB"))
+      end
+=end
+      def new_column_with_comment(field, default, type, null, collation, comment) # :nodoc:
+        #puts "NumericTypeColumn::ActiveRecord::MysqlAdapterPatch#new_column_with_comment: '#{comment}'"
+        "#{self.class.name}::Column".constantize.new(field, default, type, null, collation, comment)
+      end
+      
+      def table_options(table_name)
+        sql = "SHOW TABLE STATUS "
+        sql << "IN #{quote_table_name(current_database)} "
+        sql << "LIKE #{quote(table_name)}"
+        ohmy = execute_and_free(sql, 'SCHEMA') do |result|
+          each_hash(result).map do |field|
+            "ENGINE=#{field[:Engine]} COLLATE=#{field[:Collation]} COMMENT='#{field[:Comment]}'"
+          end
+        end
+        ohmy.first
+      end
+      
+      # Returns an array of +Column+ objects for the table specified by +table_name+.
+      def columns_with_comment(table_name, name = nil)#:nodoc:
+        sql = "SHOW FULL FIELDS FROM #{quote_table_name(table_name)}"
+        execute_and_free(sql, 'SCHEMA') do |result|
+          each_hash(result).map do |field|
+            new_column_with_comment(field[:Field], field[:Default], field[:Type], field[:Null] == "YES", field[:Collation], field[:Comment])
+          end
+        end
+      end
+      
+      protected
+      
+      def add_column_sql_with_unsigned(table_name, column_name, type, options = {})
+        #puts "NumericTypeColumn::ActiveRecord::MysqlAdapterPatch: add_column_sql_with_unsigned(table_name: #{table_name}, column_name: #{column_name}, type: #{type}, options: #{options})"
+        is_unsigned_valid = (((options.has_key? :unsigned) && (options[:unsigned] == true)) && (['integer', 'decimal', 'float', 'boolean'].include? type.to_s))
+        add_column_sql = "ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale], is_unsigned_valid)}"
+        add_column_options!(add_column_sql, options)
+        add_column_position!(add_column_sql, options)
+        add_column_sql
+      end
+      
+      def type_to_sql_with_unsigned(type, limit = nil, precision = nil, scale = nil, unsigned = false)
+        #puts "NumericTypeColumn::ActiveRecord::MysqlAdapterPatch: type_to_sql_with_unsigned(type: #{type}, limit: #{limit}, precision: #{precision}, scale: #{scale}, unsigned: #{unsigned})..."
+        sql = type_to_sql_without_unsigned(type, limit, precision, scale)
+        sql << ' UNSIGNED' if unsigned && (['integer', 'decimal', 'float', 'boolean'].include? type.to_s)
+        sql
+      end
+      
+      def add_column_options_with_comment!(sql, options = {})
+        #puts "NumericTypeColumn::ActiveRecord::MysqlAdapterPatch: add_column_options_with_comment!(sql: #{sql}, options: #{})"
+        add_column_options_without_comment!(sql, options)
+        sql << " COMMENT '#{options[:comment]}'" if options[:comment]
+        sql
+      end
+      
+    end
+  
+  end
+
+end

data/lib/numeric_type_column/active_record/schema_dumper_patch.rb

@@ -0,0 +1,102 @@
+module NumericTypeColumn
+  module ActiveRecord
+    module SchemaDumperPatch
+      
+      def self.included(base)
+        #puts "NumericTypeColumn::ActiveRecord::SchemaDumperPatch included to #{base.name}!"
+        base.send :alias_method_chain, :table,  :unsigned_and_comment
+      end
+      
+      # Override de #table
+      def table_with_unsigned_and_comment(table, stream)
+        columns = @connection.columns(table)
+        
+        begin
+          tbl = StringIO.new
+
+          # first dump primary key column
+          if @connection.respond_to?(:pk_and_sequence_for)
+            pk, _ = @connection.pk_and_sequence_for(table)
+          elsif @connection.respond_to?(:primary_key)
+            pk = @connection.primary_key(table)
+          end
+          
+          tbl.print "  create_table #{remove_prefix_and_suffix(table).inspect}"
+          if columns.detect { |c| c.name == pk }
+            if pk != 'id'
+              tbl.print %Q(, :primary_key => "#{pk}")
+            end
+          else
+            tbl.print ", :id => false"
+          end
+          tbl.print ", :force => true"
+          tbl.print ", :options =>\"#{@connection.table_options(table)}\""
+          tbl.puts " do |t|"
+
+          # then dump all non-primary key columns
+          column_specs = columns.map do |column|
+            raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" if @types[column.type].nil?
+            next if column.name == pk
+            spec = {}
+            spec[:name]      = column.name.inspect
+
+            # AR has an optimization which handles zero-scale decimals as integers. This
+            # code ensures that the dumper still dumps the column as a decimal.
+            spec[:type]      = if column.type == :integer && [/^numeric/, /^decimal/].any? { |e| e.match(column.sql_type) }
+                                 'decimal'
+                               else
+                                 column.type.to_s
+                               end
+            spec[:unsigned]  = 'true' if /unsigned/i.match(column.sql_type)
+            spec[:limit]     = column.limit.inspect if column.limit != @types[column.type][:limit] && spec[:type] != 'decimal'
+            spec[:precision] = column.precision.inspect if column.precision
+            spec[:scale]     = column.scale.inspect if column.scale
+            spec[:null]      = 'false' unless column.null
+            spec[:default]   = default_string(column.default) if column.has_default?
+            spec[:comment]   = "\"#{column.comment}\"" unless column.comment.nil?
+            (spec.keys - [:name, :type]).each{ |k| spec[k].insert(0, "#{k.inspect} => ")}
+            spec
+          end.compact
+          
+          # find all migration keys used in this table
+          keys = [:name, :limit, :unsigned, :precision, :scale, :default, :null, :comment] & column_specs.map{ |k| k.keys }.flatten
+
+          # figure out the lengths for each column based on above keys
+          lengths = keys.map{ |key| column_specs.map{ |spec| spec[key] ? spec[key].length + 2 : 0 }.max }
+
+          # the string we're going to sprintf our values against, with standardized column widths
+          format_string = lengths.map{ |len| "%-#{len}s" }
+
+          # find the max length for the 'type' column, which is special
+          type_length = column_specs.map{ |column| column[:type].length }.max
+
+          # add column type definition to our format string
+          format_string.unshift "    t.%-#{type_length}s "
+
+          format_string *= ''
+
+          column_specs.each do |colspec|
+            values = keys.zip(lengths).map{ |key, len| colspec.key?(key) ? colspec[key] + ", " : " " * len }
+            values.unshift colspec[:type]
+            tbl.print((format_string % values).gsub(/,\s*$/, ''))
+            tbl.puts
+          end
+
+          tbl.puts "  end"
+          tbl.puts
+
+          indexes(table, tbl)
+
+          tbl.rewind
+          stream.print tbl.read
+        rescue => e
+          stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
+          stream.puts "#   #{e.message}"
+          stream.puts
+        end
+
+        stream
+      end
+    end
+  end
+end

data/lib/numeric_type_column/active_record/{table_definition_extension.rb → table_definition_patch.rb}

@@ -4,15 +4,15 @@ module NumericTypeColumn
 
   module ActiveRecord
   
-    module TableDefinitionExtension
+    module TableDefinitionPatch
       
       def self.included(base)
-        #puts "NumericTypeColumn::ActiveRecord::TableDefinitionExtension included to #{base.name}!"
+        #puts "NumericTypeColumn::ActiveRecord::TableDefinitionPatch included to #{base.name}!"
         base.send :alias_method_chain, :column, :unsigned_and_comment
       end
     
       def column_with_unsigned_and_comment(name, type, options = {})
-        #puts "NumericTypeColumn::ActiveRecord::TableDefinitionExtension: column_with_unsigned_and_comment(name: #{name}, type: #{type}, options = {})..."
+        #puts "NumericTypeColumn::ActiveRecord::TableDefinitionPatch: column_with_unsigned_and_comment(name: #{name}, type: #{type}, options = {})..."
         ret_column = column_without_unsigned_and_comment(name, type, options)
         ret_column[name].unsigned = options[:unsigned]
         ret_column[name].comment = options[:comment]

data/lib/numeric_type_column/active_record.rb

@@ -3,11 +3,14 @@
 module NumericTypeColumn
   
   module ActiveRecord
-    autoload :AbstractMysqlAdapterExtension,            'numeric_type_column/active_record/abstract_mysql_adapter_extension'
-    autoload :BaseExtension,                            'numeric_type_column/active_record/base_extension'
-    autoload :BelongsToPolimorphicAssociationExtension, 'numeric_type_column/active_record/belongs_to_polimorphic_association_extension'
-    autoload :ColumnDefinitionExtension,                'numeric_type_column/active_record/column_definition_extension'
-    autoload :TableDefinitionExtension,                 'numeric_type_column/active_record/table_definition_extension'
+    autoload :MysqlAdapterPatch,      'numeric_type_column/active_record/mysql_adapter_patch'
+    autoload :ColumnDefinitionPatch,  'numeric_type_column/active_record/column_definition_patch'
+    autoload :TableDefinitionPatch,   'numeric_type_column/active_record/table_definition_patch'
+    autoload :SchemaDumperPatch,      'numeric_type_column/active_record/schema_dumper_patch'
+    
+    
+    autoload :BasePatch,                            'numeric_type_column/active_record/base_patch'
+    autoload :BelongsToPolymorphicAssociationPatch, 'numeric_type_column/active_record/belongs_to_polymorphic_association_patch'
   end
 
 end

data/lib/numeric_type_column/railtie.rb

@@ -6,15 +6,21 @@ module NumericTypeColumn
       ActiveSupport.on_load(:active_record) do
       
         # Patches para permitir definir columnas UNSIGNED y COMMENTS en MySQL:
-        ::ActiveRecord::ConnectionAdapters::ColumnDefinition.send     :include, NumericTypeColumn::ActiveRecord::ColumnDefinitionExtension
-        ::ActiveRecord::ConnectionAdapters::TableDefinition.send      :include, NumericTypeColumn::ActiveRecord::TableDefinitionExtension
-        ::ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter.send :include, NumericTypeColumn::ActiveRecord::AbstractMysqlAdapterExtension
+        adaptr_module = "::ActiveRecord::ConnectionAdapters"
+        "#{adaptr_module}::ColumnDefinition".constantize.send             :include, NumericTypeColumn::ActiveRecord::ColumnDefinitionPatch
+        "#{adaptr_module}::TableDefinition".constantize.send              :include, NumericTypeColumn::ActiveRecord::TableDefinitionPatch
+        ["MysqlAdapter", "Mysql2Adapter"].each do |mysql_adapter_name|
+          if adaptr_module.constantize.const_defined? mysql_adapter_name
+            "#{adaptr_module}::#{mysql_adapter_name}".constantize.send :include, NumericTypeColumn::ActiveRecord::MysqlAdapterPatch
+          end
+        end
+        ::ActiveRecord::SchemaDumper.send :include, NumericTypeColumn::ActiveRecord::SchemaDumperPatch
         
         # Patch para permitir STI con columna numerica:
-        ::ActiveRecord::Base.extend NumericTypeColumn::ActiveRecord::BaseExtension
+        ::ActiveRecord::Base.extend NumericTypeColumn::ActiveRecord::BasePatch
         
         # Patch para permitir polymorphs con columna foreign_type numerica:
-        #::ActiveRecord::Associations::BelongsToPolymorphicAssociation.send :include, NumericTypeColumn::ActiveRecord::BelongsToPolymorphicAssociationExtension
+        #::ActiveRecord::Associations::BelongsToPolymorphicAssociation.extend NumericTypeColumn::ActiveRecord::BelongsToPolymorphicAssociationPatch
         
         
       end

data/lib/numeric_type_column/version.rb

@@ -1,3 +1,3 @@
 module NumericTypeColumn
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/test/dummy/README.rdoc

@@ -0,0 +1,261 @@
+== Welcome to Rails
+
+Rails is a web-application framework that includes everything needed to create
+database-backed web applications according to the Model-View-Control pattern.
+
+This pattern splits the view (also called the presentation) into "dumb"
+templates that are primarily responsible for inserting pre-built data in between
+HTML tags. The model contains the "smart" domain objects (such as Account,
+Product, Person, Post) that holds all the business logic and knows how to
+persist themselves to a database. The controller handles the incoming requests
+(such as Save New Account, Update Product, Show Post) by manipulating the model
+and directing data to the view.
+
+In Rails, the model is handled by what's called an object-relational mapping
+layer entitled Active Record. This layer allows you to present the data from
+database rows as objects and embellish these data objects with business logic
+methods. You can read more about Active Record in
+link:files/vendor/rails/activerecord/README.html.
+
+The controller and view are handled by the Action Pack, which handles both
+layers by its two parts: Action View and Action Controller. These two layers
+are bundled in a single package due to their heavy interdependence. This is
+unlike the relationship between the Active Record and Action Pack that is much
+more separate. Each of these packages can be used independently outside of
+Rails. You can read more about Action Pack in
+link:files/vendor/rails/actionpack/README.html.
+
+
+== Getting Started
+
+1. At the command prompt, create a new Rails application:
+       <tt>rails new myapp</tt> (where <tt>myapp</tt> is the application name)
+
+2. Change directory to <tt>myapp</tt> and start the web server:
+       <tt>cd myapp; rails server</tt> (run with --help for options)
+
+3. Go to http://localhost:3000/ and you'll see:
+       "Welcome aboard: You're riding Ruby on Rails!"
+
+4. Follow the guidelines to start developing your application. You can find
+the following resources handy:
+
+* The Getting Started Guide: http://guides.rubyonrails.org/getting_started.html
+* Ruby on Rails Tutorial Book: http://www.railstutorial.org/
+
+
+== Debugging Rails
+
+Sometimes your application goes wrong. Fortunately there are a lot of tools that
+will help you debug it and get it back on the rails.
+
+First area to check is the application log files. Have "tail -f" commands
+running on the server.log and development.log. Rails will automatically display
+debugging and runtime information to these files. Debugging info will also be
+shown in the browser on requests from 127.0.0.1.
+
+You can also log your own messages directly into the log file from your code
+using the Ruby logger class from inside your controllers. Example:
+
+  class WeblogController < ActionController::Base
+    def destroy
+      @weblog = Weblog.find(params[:id])
+      @weblog.destroy
+      logger.info("#{Time.now} Destroyed Weblog ID ##{@weblog.id}!")
+    end
+  end
+
+The result will be a message in your log file along the lines of:
+
+  Mon Oct 08 14:22:29 +1000 2007 Destroyed Weblog ID #1!
+
+More information on how to use the logger is at http://www.ruby-doc.org/core/
+
+Also, Ruby documentation can be found at http://www.ruby-lang.org/. There are
+several books available online as well:
+
+* Programming Ruby: http://www.ruby-doc.org/docs/ProgrammingRuby/ (Pickaxe)
+* Learn to Program: http://pine.fm/LearnToProgram/ (a beginners guide)
+
+These two books will bring you up to speed on the Ruby language and also on
+programming in general.
+
+
+== Debugger
+
+Debugger support is available through the debugger command when you start your
+Mongrel or WEBrick server with --debugger. This means that you can break out of
+execution at any point in the code, investigate and change the model, and then,
+resume execution! You need to install ruby-debug to run the server in debugging
+mode. With gems, use <tt>sudo gem install ruby-debug</tt>. Example:
+
+  class WeblogController < ActionController::Base
+    def index
+      @posts = Post.all
+      debugger
+    end
+  end
+
+So the controller will accept the action, run the first line, then present you
+with a IRB prompt in the server window. Here you can do things like:
+
+  >> @posts.inspect
+  => "[#<Post:0x14a6be8
+          @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>,
+       #<Post:0x14a6620
+          @attributes={"title"=>"Rails", "body"=>"Only ten..", "id"=>"2"}>]"
+  >> @posts.first.title = "hello from a debugger"
+  => "hello from a debugger"
+
+...and even better, you can examine how your runtime objects actually work:
+
+  >> f = @posts.first
+  => #<Post:0x13630c4 @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>
+  >> f.
+  Display all 152 possibilities? (y or n)
+
+Finally, when you're ready to resume execution, you can enter "cont".
+
+
+== Console
+
+The console is a Ruby shell, which allows you to interact with your
+application's domain model. Here you'll have all parts of the application
+configured, just like it is when the application is running. You can inspect
+domain models, change values, and save to the database. Starting the script
+without arguments will launch it in the development environment.
+
+To start the console, run <tt>rails console</tt> from the application
+directory.
+
+Options:
+
+* Passing the <tt>-s, --sandbox</tt> argument will rollback any modifications
+  made to the database.
+* Passing an environment name as an argument will load the corresponding
+  environment. Example: <tt>rails console production</tt>.
+
+To reload your controllers and models after launching the console run
+<tt>reload!</tt>
+
+More information about irb can be found at:
+link:http://www.rubycentral.org/pickaxe/irb.html
+
+
+== dbconsole
+
+You can go to the command line of your database directly through <tt>rails
+dbconsole</tt>. You would be connected to the database with the credentials
+defined in database.yml. Starting the script without arguments will connect you
+to the development database. Passing an argument will connect you to a different
+database, like <tt>rails dbconsole production</tt>. Currently works for MySQL,
+PostgreSQL and SQLite 3.
+
+== Description of Contents
+
+The default directory structure of a generated Ruby on Rails application:
+
+  |-- app
+  |   |-- assets
+  |       |-- images
+  |       |-- javascripts
+  |       `-- stylesheets
+  |   |-- controllers
+  |   |-- helpers
+  |   |-- mailers
+  |   |-- models
+  |   `-- views
+  |       `-- layouts
+  |-- config
+  |   |-- environments
+  |   |-- initializers
+  |   `-- locales
+  |-- db
+  |-- doc
+  |-- lib
+  |   `-- tasks
+  |-- log
+  |-- public
+  |-- script
+  |-- test
+  |   |-- fixtures
+  |   |-- functional
+  |   |-- integration
+  |   |-- performance
+  |   `-- unit
+  |-- tmp
+  |   |-- cache
+  |   |-- pids
+  |   |-- sessions
+  |   `-- sockets
+  `-- vendor
+      |-- assets
+          `-- stylesheets
+      `-- plugins
+
+app
+  Holds all the code that's specific to this particular application.
+
+app/assets
+  Contains subdirectories for images, stylesheets, and JavaScript files.
+
+app/controllers
+  Holds controllers that should be named like weblogs_controller.rb for
+  automated URL mapping. All controllers should descend from
+  ApplicationController which itself descends from ActionController::Base.
+
+app/models
+  Holds models that should be named like post.rb. Models descend from
+  ActiveRecord::Base by default.
+
+app/views
+  Holds the template files for the view that should be named like
+  weblogs/index.html.erb for the WeblogsController#index action. All views use
+  eRuby syntax by default.
+
+app/views/layouts
+  Holds the template files for layouts to be used with views. This models the
+  common header/footer method of wrapping views. In your views, define a layout
+  using the <tt>layout :default</tt> and create a file named default.html.erb.
+  Inside default.html.erb, call <% yield %> to render the view using this
+  layout.
+
+app/helpers
+  Holds view helpers that should be named like weblogs_helper.rb. These are
+  generated for you automatically when using generators for controllers.
+  Helpers can be used to wrap functionality for your views into methods.
+
+config
+  Configuration files for the Rails environment, the routing map, the database,
+  and other dependencies.
+
+db
+  Contains the database schema in schema.rb. db/migrate contains all the
+  sequence of Migrations for your schema.
+
+doc
+  This directory is where your application documentation will be stored when
+  generated using <tt>rake doc:app</tt>
+
+lib
+  Application specific libraries. Basically, any kind of custom code that
+  doesn't belong under controllers, models, or helpers. This directory is in
+  the load path.
+
+public
+  The directory available for the web server. Also contains the dispatchers and the
+  default HTML files. This should be set as the DOCUMENT_ROOT of your web
+  server.
+
+script
+  Helper scripts for automation and generation.
+
+test
+  Unit and functional tests along with fixtures. When using the rails generate
+  command, template test files will be generated for you and placed in this
+  directory.
+
+vendor
+  External libraries that the application depends on. Also includes the plugins
+  subdirectory. If the app has frozen rails, those gems also go here, under
+  vendor/rails/. This directory is in the load path.

data/test/dummy/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/test/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,15 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// the compiled file.
+//
+// WARNING: THE FIRST BLANK LINE MARKS THE END OF WHAT'S TO BE PROCESSED, ANY BLANK LINE SHOULD
+// GO AFTER THE REQUIRES BELOW.
+//
+//= require jquery
+//= require jquery_ujs
+//= require_tree .

data/test/dummy/app/assets/javascripts/unsigned_columns_tests.js

@@ -0,0 +1,2 @@
+// Place all the behaviors and hooks related to the matching controller here.
+// All this logic will automatically be available in application.js.