sequel_migration_builder 0.0.4 → 0.0.5

data/README.rdoc

@@ -19,6 +19,8 @@ as a hash. A sample YAML version might look like:
 
     example_table:
       primary_key: id
+      table_options:
+        engine: myisam
       columns:
         - name: id
           column_type: integer
@@ -39,6 +41,8 @@ as a hash. A sample YAML version might look like:
 * Dropping tables when they are removed from the schema
 * Automigrate functionality
 * Dealing with renames in some way (even if just logging that they would be possible).
+* Changing table options with alter table
+* More database type parsers
 
 == Note on Patches/Pull Requests
  

data/Rakefile

@@ -44,3 +44,8 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+desc "Flog this baby!"
+task :flog do
+  sh 'find lib -name "*.rb" | xargs flog'
+end

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.0.5

data/lib/sequel/migration_builder.rb

@@ -1,3 +1,4 @@
+require 'sequel/extensions/blank'
 require 'sequel/schema/db_column'
 require 'sequel/schema/db_schema_parser'
 require 'sequel/schema/alter_table_operations'
@@ -60,52 +61,58 @@ module Sequel
 
       add_line "down do"
       alter_tables(current_tables, tables, :down)
-      indent do
-        new_tables.reverse.each {|table_name| add_line "drop_table #{table_name.inspect}" }
-      end
+      drop_new_tables(new_tables)
       add_line "end"
     end
 
     # Generates any create table statements for new tables.
     #
-    def create_new_tables(new_tables, tables)
-      i = 0
-      new_tables.each do |table_name|
-        i += 1
-        indent { create_table_statement table_name, tables[table_name] }
-        add_blank_line unless i == tables.size
+    def create_new_tables(new_table_names, tables)
+      each_table(new_table_names, tables) do |table_name, table, last_table|
+        create_table_statement table_name, table
+        add_blank_line unless last_table
       end
     end
 
-    # Generates any alter table statements for current tables.
+    # Generates any drop table statements for new tables.
     #
-    def alter_tables(current_tables, tables, direction)
-      i = 0
+    def drop_new_tables(new_table_names)
       indent do
-        current_tables.each do |table_name|
-          i += 1
-          hsh = tables[table_name].dup
-          hsh[:columns] = hsh[:columns].map {|c| Schema::DbColumn.build_from_hash(c) }
-          operations = Schema::AlterTableOperations.build(@db_tables[table_name], hsh)
-          unless operations.empty?
-            add_line "alter_table #{table_name.inspect} do"
-            indent do
-              operations.each {|op| add_line op.__send__(direction) }
-            end
-            add_line "end"
-            add_blank_line unless i == tables.size
-          end
+        new_table_names.reverse.each {|table_name| add_line "drop_table #{table_name.inspect}" }
+      end
+    end
+
+    # Generates any alter table statements for current tables.
+    #
+    def alter_tables(current_table_names, tables, direction)
+      each_table(current_table_names, tables) do |table_name, table, last_table|
+        hsh = table.dup
+        hsh[:columns] = hsh[:columns].map {|c| Schema::DbColumn.build_from_hash(c) }
+        operations = Schema::AlterTableOperations.build(@db_tables[table_name], hsh)
+        unless operations.empty?
+          alter_table_statement table_name, operations, direction
+          add_blank_line unless last_table
         end
       end
     end
 
+    # Generates an individual alter table statement.
+    #
+    def alter_table_statement(table_name, operations, direction)
+      add_line "alter_table #{table_name.inspect} do"
+      indent do
+        operations.each {|op| add_line op.__send__(direction) }
+      end
+      add_line "end"
+    end
+
     # Generates an individual create_table statement.
     #
     def create_table_statement(table_name, table)
-      add_line "create_table #{table_name.inspect}#{options_str(table)} do"
+      add_line "create_table #{table_name.inspect}#{pretty_hash(table[:table_options])} do"
       indent do
-        table[:columns].map {|c| Schema::DbColumn.build_from_hash(c) }.each do |column|
-          add_line column.define_statement
+        table[:columns].each do |c| 
+          add_line Schema::DbColumn.build_from_hash(c).define_statement
         end
         if table[:primary_key]
           add_blank_line
@@ -119,8 +126,20 @@ module Sequel
 
     attr_reader :result
 
-    def options_str(table)
-      ", " + table[:table_options].inspect.gsub(/^\{|\}$/,'').gsub("=>", " => ") if table[:table_options]
+    def each_table(table_names, tables)
+      i = 0
+      indent do
+        table_names.each do |table_name|
+          i += 1
+          yield table_name, tables[table_name], i == tables.size
+        end
+      end
+    end
+
+    # Returns a string representing a hash as ':foo => :bar'
+    # rather than '{:foo=.:bar}'
+    def pretty_hash(hash)
+      ", " + hash.inspect.gsub(/^\{|\}$/,'').gsub("=>", " => ") if hash
     end
 
     def table_names(tables)

data/lib/sequel/schema/db_column.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 module Sequel
   module Schema
     DbColumn = Struct.new(:name, :column_type, :null, :default, :unsigned, :size, :elements)
@@ -8,11 +10,20 @@ module Sequel
     # migration operations.
     #
     class DbColumn
+      # Database column types that hold integers.
+      INTEGER_TYPES = [:tinyint, :integer, :smallint, :mediumint, :bigint]
+
+      # Database column types that hold fractional values.
+      DECIMAL_TYPES = [:decimal, :float, :bigdecimal]
+
+      # All numeric database column types.
+      NUMERIC_TYPES = INTEGER_TYPES + DECIMAL_TYPES
+
       # Builds a DbColumn from a Hash of attribute values. Keys 
       # can be strings or symbols.
       #
       def self.build_from_hash(attrs={})
-        new *members.map {|key| attrs[key] || attrs[key.to_sym] }
+        self.new *members.map {|key| attrs[key] || attrs[key.to_sym] }
       end
 
       # Returns a Sequel migration statement to define a column in a
@@ -56,40 +67,97 @@ module Sequel
         ["set_column_type #{name.inspect}", column_type.inspect, change_options].compact.join(", ")
       end
 
-      # Returns an Array of attributes that are different between this
+      # Returns an Set of attributes that are different between this
       # and another column.
       #
       def diff(other)
-        result = []
-        each_pair {|key, value| result << key if other[key] != value }
-        result
+        { :null        => :boolean_attribute_different?,
+          :unsigned    => :boolean_attribute_different?,
+          :name        => :attribute_different?,
+          :column_type => :attribute_different?,
+          :elements    => :attribute_different?,
+          :default     => :defaults_different?,
+          :size        => :sizes_different? 
+        }.select {|attribute, method| __send__(method, attribute, other) }.map {|a| a.first }.to_set
+      end
+
+      # Returns true if this column is numeric
+      #
+      def numeric?
+        NUMERIC_TYPES.include?(column_type)
       end
 
       private
 
+      def attribute_different?(sym, other)
+        other[sym] != self[sym]
+      end
+
+      def boolean_attribute_different?(sym, other)
+        (!!other[sym]) != (!!self[sym])
+      end
+
+      def numeric_attribute_different?(sym, other)
+        (self[sym] || 0) != (other[sym] || 0)
+      end
+
+      def sizes_different?(_, other)
+        # Null size indicates 'lack of interest' in the size
+        size && other.size && other.size != size
+      end
+
+      def defaults_different?(_, other)
+        # Complicated by dealing with database defaults if the column
+        # does not allow null values.
+        if null == true || other.null == true
+          attribute_different?(:default, other)
+        elsif numeric? && other.numeric?
+          numeric_attribute_different?(:default, other)
+        else
+          ! (default.blank? && other.default.blank?) && other.default != default
+        end
+      end
+
       def change_options
-        opts = []
+        opts = OptionBuilder.new
 
-        opts << ":default => #{default.inspect}"
+        opts.set :default, default
         # seems odd, but we only want to output if unsigned is a true
         # boolean, not if it is nil.
-        opts << ":unsigned => #{unsigned.inspect}" if unsigned == true || unsigned == false
-        opts << ":size => #{size.inspect}"         if size
-        opts << ":elements => #{elements.inspect}" if elements
-
-        opts.join(", ") unless opts.empty?
+        opts.set :unsigned, unsigned if numeric? && (unsigned == true || unsigned == false)
+        opts.set :size, size         if size
+        opts.set :elements, elements if elements
+        
+        opts.render
       end
 
       def options
-        opts = []
+        opts = OptionBuilder.new
+        
+        opts.set :null, !!null       if null != true || column_type == :timestamp
+        opts.set :default, default   if default || column_type == :timestamp
+        opts.set :unsigned, true     if numeric? && unsigned
+        opts.set :size, size         if size
+        opts.set :elements, elements if elements
 
-        opts << ":null => #{(!!null).inspect}"     if null != true || column_type == :timestamp
-        opts << ":default => #{default.inspect}"   if default || column_type == :timestamp
-        opts << ":unsigned => true"                if unsigned
-        opts << ":size => #{size.inspect}"         if size
-        opts << ":elements => #{elements.inspect}" if elements
+        opts.render
+      end
 
-        opts.join(", ") unless opts.empty?
+      # Formats column options in a Sequel migration
+      class OptionBuilder
+        def initialize
+          @opts = []
+        end
+        
+        # Sets column option name to a value.
+        def set(name, value)
+          @opts << "#{name.inspect} => #{value.inspect}"
+        end
+        
+        # Renders the column option hash in a pretty format.
+        def render
+          @opts.join(", ") unless @opts.empty?
+        end
       end
     end
   end

data/lib/sequel/schema/db_schema_parser.rb

@@ -27,11 +27,10 @@ module Sequel
       #          :table2 => { ... } }
       #
       def parse_db_schema
-        result = {}
-        @db.tables.each do |table_name|
+        @db.tables.inject({}) do |result, table_name|
           result[table_name] = {:columns => parse_table_schema(@db.schema(table_name))}
+          result
         end
-        result
       end
 
       # Extracts an array of hashes representing the columns in the
@@ -39,17 +38,14 @@ module Sequel
       #
       def parse_table_schema(db_schema)
         db_schema.map do |column|
-          attrs = { 
-            :name        => column.first,
-            :default     => column.last[:ruby_default],
-            :null        => column.last[:allow_null],
-            :column_type => parse_type(column.last[:db_type]),
-            :unsigned    => column.last[:db_type].include?(" unsigned") 
-          }
-          attrs[:size]     = extract_size(column) if column.last[:type] == :string
-          attrs[:elements] = extract_enum_elements(column) if attrs[:column_type] == :enum
-          
-          DbColumn.build_from_hash(attrs)
+          type = parse_type(column.last[:db_type])
+          DbColumn.build_from_hash(:name        => column.first,
+                                   :default     => column.last[:ruby_default],
+                                   :null        => column.last[:allow_null],
+                                   :column_type => type,
+                                   :unsigned    => extract_unsigned(column.last[:db_type], type),
+                                   :size        => extract_size(column.last[:db_type], type),
+                                   :elements    => extract_enum_elements(column.last[:db_type], type))
         end
       end
 
@@ -80,13 +76,25 @@ module Sequel
 
       private
 
-      def extract_size(column)
-        match = column.last[:db_type].match(/\((\d+)\)/)
-        match[1].to_i if match && match[1]
+      def extract_unsigned(db_type_string, type)
+        return unless DbColumn::NUMERIC_TYPES.include?(type)
+        db_type_string.include?(" unsigned")
       end
 
-      def extract_enum_elements(column)
-        match = column.last[:db_type].match(/\(([^)]+)\)/)
+      def extract_size(db_type_string, type)
+        return if DbColumn::INTEGER_TYPES.include?(type)
+
+        match = db_type_string.match(/\(([0-9, ]+)\)/)
+        if match && match[1]
+          n = match[1].split(/\s*,\s*/).map {|i| i.to_i }
+          n.size == 1 ? n.first : n
+        end
+      end
+
+      def extract_enum_elements(db_type_string, type)
+        return unless type == :enum
+
+        match = db_type_string.match(/\(([^)]+)\)/)
         eval('[' + match[1] + ']') if match[1]
       end
     end

data/sequel_migration_builder.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{sequel_migration_builder}
-  s.version = "0.0.4"
+  s.version = "0.0.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Roland Swingler"]
-  s.date = %q{2010-06-22}
+  s.date = %q{2010-06-23}
   s.description = %q{Build Sequel Migrations based on the differences between two schemas}
   s.email = %q{roland.swingler@gmail.com}
   s.extra_rdoc_files = [

data/spec/db_column_spec.rb

@@ -32,10 +32,59 @@ describe Sequel::Schema::DbColumn do
 
   it "should be diffable with another DbColumn" do
     other = Sequel::Schema::DbColumn.new(:foo, :smallint, false, 10, true, 10, nil)
-    @column.diff(other).should == [:column_type]
+    @column.diff(other).should == [:column_type].to_set
 
     other = Sequel::Schema::DbColumn.new(:foo, :integer, true, 11, true, 10, nil)
-    @column.diff(other).should == [:null, :default]
+    @column.diff(other).should == [:null, :default].to_set
+  end
+
+  it "should not consider allowing null being nil different from false" do
+    a = Sequel::Schema::DbColumn.new(:foo, :smallint, false, 10, true, 10, nil)
+    b = Sequel::Schema::DbColumn.new(:foo, :smallint, nil, 10, true, 10, nil)
+    a.diff(b).should be_empty
+    b.diff(a).should be_empty
+  end
+
+  it "should not consider size to be different if one of the sizes is nil" do
+    a = Sequel::Schema::DbColumn.new(:foo, :smallint, false, 10, true, 10, nil)
+    b = Sequel::Schema::DbColumn.new(:foo, :smallint, false, 10, true, nil, nil)
+    a.diff(b).should be_empty
+    b.diff(a).should be_empty
+  end
+
+  it "should not consider 0 to be different from null if the column does not allow nulls" do
+    a = Sequel::Schema::DbColumn.new(:foo, :smallint, false, 0, true, 10, nil)
+    b = Sequel::Schema::DbColumn.new(:foo, :smallint, false, nil, true, nil, nil)
+    a.diff(b).should be_empty
+    b.diff(a).should be_empty
+  end
+
+  it "should consider 0 to be different from null if the column does allow nulls" do
+    a = Sequel::Schema::DbColumn.new(:foo, :smallint, true, 0, true, 10, nil)
+    b = Sequel::Schema::DbColumn.new(:foo, :smallint, true, nil, true, nil, nil)
+    a.diff(b).should == [:default].to_set
+    b.diff(a).should == [:default].to_set
+  end
+
+  it "should consider 1 to be different from null" do
+    a = Sequel::Schema::DbColumn.new(:foo, :smallint, false, 1, true, 10, nil)
+    b = Sequel::Schema::DbColumn.new(:foo, :smallint, false, nil, true, nil, nil)
+    a.diff(b).should == [:default].to_set
+    b.diff(a).should == [:default].to_set
+  end
+
+  it "should not consider '' to be different from null if the column does not allow nulls" do
+    a = Sequel::Schema::DbColumn.new(:foo, :varchar, false, '', true, 10, nil)
+    b = Sequel::Schema::DbColumn.new(:foo, :varchar, false, nil, true, nil, nil)
+    a.diff(b).should be_empty
+    b.diff(a).should be_empty
+  end
+
+  it "should consider '' to be different from null if the column allows null" do
+    a = Sequel::Schema::DbColumn.new(:foo, :varchar, true, '', true, 10, nil)
+    b = Sequel::Schema::DbColumn.new(:foo, :varchar, true, nil, true, nil, nil)
+    a.diff(b).should == [:default].to_set
+    b.diff(a).should == [:default].to_set
   end
 
   it "should be buildable from a Hash" do

data/spec/db_schema_parser_spec.rb

@@ -66,16 +66,38 @@ describe "A hash in the array returned by Sequel::Schema::DbSchemaParser#parse_t
     @parser.parse_table_schema(@schema).first.size.should == 20
   end
 
+  it "should contain a :size attribute for decimal columns" do
+    set_db_type "decimal(14,5)"
+    @parser.parse_table_schema(@schema).first.size.should == [14,5]
+  end
+
   it "should contain :unsigned false if a numeric column is not unsigned" do
     set_db_type "int(10)"
     @parser.parse_table_schema(@schema).first.unsigned.should == false
   end
 
-  it "should contain :unsigned true if a numeric column is unsigned" do
+  it "should contain :unsigned true if an integer column is unsigned" do
     set_db_type "int(10) unsigned"
     @parser.parse_table_schema(@schema).first.unsigned.should == true
   end
 
+  it "should contain :unsigned true if a decimal column is unsigned" do
+    @schema = [[:example_column, 
+                { :type => nil, 
+                  :default => "1", 
+                  :ruby_default => 1, 
+                  :primary_key => false, 
+                  :db_type => "decimal(10,2) unsigned", 
+                  :allow_null => true   }]]
+
+    @parser.parse_table_schema(@schema).first.unsigned.should == true
+  end
+
+  it "should not contain an :unsigned value if not a numeric column" do
+    set_db_type "varchar(10)", :string
+    @parser.parse_table_schema(@schema).first.unsigned.should == nil
+  end
+
   it "should contain the elements of an enum column" do
     set_db_type "enum('foo','bar')"
     @parser.parse_table_schema(@schema).first.elements.should == ['foo', 'bar']

data/spec/spec_helper.rb

@@ -1,5 +1,7 @@
+require 'rubygems'
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'sequel'
 require 'sequel/migration_builder'
 require 'spec'
 require 'spec/autorun'

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 4
-  version: 0.0.4
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - Roland Swingler
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-22 00:00:00 +01:00
+date: 2010-06-23 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency