legacy_data 0.1.6 → 0.1.7

data/VERSION

@@ -1 +1 @@
-0.1.6
+0.1.7

data/generators/models_from_tables/templates/model.rb

@@ -21,11 +21,14 @@ class <%= class_name -%> < ActiveRecord::Base
   -%>  #validates_uniqueness_of_multiple_column_constraint :<%= cols.inspect %>
   <%- end -%>
   <%= "validates_presence_of #{constraints[:presence_of].map {|cols| cols.downcase.to_sym.inspect}.join(', ')}" unless constraints[:presence_of].blank? %>
-  <%- constraints[:boolean_presence].each do |col| 
-      -%>  validates_inclusion_of    <%= col.to_sym.inspect %>,       :in => %w(true false)
-  <%- end -%>
+  <%- constraints[:inclusion_of].each do |col, possible_values| 
+      -%>  def self.possible_values_for_<%= col %>
+    [ <%= possible_values %> ]
+  end
+  validates_inclusion_of    <%= col.to_sym.inspect %>,       :in => possible_values_for_<%= col %>, :message => "is not one of (#{possible_values_for_<%= col %>.join(', ')})"
+  <%- end if constraints[:inclusion_of] -%>
   <%- [:allow_nil, :do_not_allow_nil].each do |nullable| 
-        unless constraints[:numericality_of][nullable].blank?
+        unless constraints[:numericality_of][nullable].blank? 
     -%>  <%= "validates_numericality_of #{constraints[:numericality_of][nullable].map {|cols| cols.downcase.to_sym.inspect}.join(', ')}" %><%= ", {:allow_nil=>true}" if nullable == :allow_nil %>
   <%-   end
       end unless constraints[:numericality_of].blank? -%>
@@ -37,6 +40,6 @@ class <%= class_name -%> < ActiveRecord::Base
     <%= sql_rule %>
     SQL
   end
-  <%- end -%>
+  <%- end if constraints[:custom] -%>
 end
 

data/legacy_data.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{legacy_data}
-  s.version = "0.1.6"
+  s.version = "0.1.7"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Alex Rothenberg"]
-  s.date = %q{2009-10-13}
+  s.date = %q{2009-10-14}
   s.description = %q{Create ActiveRecord models from an existing database}
   s.email = %q{alex@alexrothenberg.com}
   s.extra_rdoc_files = [

data/lib/legacy_data/schema.rb

@@ -82,12 +82,14 @@ module LegacyData
     end
 
     def primary_key
-      if connection.respond_to?(:pk_and_sequence_for)
-        pk, seq = connection.pk_and_sequence_for(table_name)
-      elsif connection.respond_to?(:primary_key)
-        pk = connection.primary_key(table_name)
+      if @pk.nil?
+        if connection.respond_to?(:pk_and_sequence_for)
+          @pk, seq = connection.pk_and_sequence_for(table_name)
+        elsif connection.respond_to?(:primary_key)
+          @pk = connection.primary_key(table_name)
+        end
       end
-      pk
+      @pk
     end
 
     def relations
@@ -121,17 +123,15 @@ module LegacyData
         @constraints = {}
       
         @constraints[:unique],           @constraints[:multi_column_unique] = uniqueness_constraints
-        @constraints[:boolean_presence], @constraints[:presence_of]         = presence_constraints
+        boolean_presence_columns,        @constraints[:presence_of]         = presence_constraints
         @constraints[:numericality_of]                                      = numericality_constraints
-        @constraints[:custom]                                               = custom_constraints
+        @constraints[:custom],           @constraints[:inclusion_of]        = custom_constraints
+        
+        boolean_presence_columns.each {|col| @constraints[:inclusion_of][col] = "true, false" }
       end
       @constraints
       ##### TO DO
       # presence_of schoolparentid => school_parent     - FOREIGN KEY
-      # # booleans presence_of => inclusion_of
-      # integer numericality_of                         - INTEGER COLUMNS (except foreign keys)
-      # custom /(.*) IN \(.*\)/i => inclusion_of $1, :in=> %w($2)  -- TRY TO PARSE CUSTOM SQL RULES
-      # 
     end
     
     def numericality_constraints
@@ -159,7 +159,7 @@ module LegacyData
     end
     
     def integer_columns
-      columns.select {|column| column.type == :integer }
+      columns.select {|column| column.type == :integer }.reject {|column| column.name == primary_key}
     end
 
     def columns
@@ -179,11 +179,16 @@ module LegacyData
     
     def custom_constraints
       return [] unless connection.respond_to? :constraints
-      user_constraints = {}
+      custom_constraints, inclusion_constraints = {}, {}
       connection.constraints(table_name).each do |constraint|
-        user_constraints[constraint.first.underscore.to_sym] = constraint.second
+        constraint_sql = constraint.second
+        if constraint_sql =~ /\s*\"*(\w*)\"*\s*IN\s*\((.*)\)/i
+          inclusion_constraints[$1.downcase.to_sym] = $2
+        else
+          custom_constraints[constraint.first.underscore.to_sym] = constraint_sql
+        end
       end
-      user_constraints
+      [custom_constraints, inclusion_constraints]
     end    
 
     def log msg

data/spec/functional/expected/comment.rb

@@ -8,6 +8,5 @@ class Comment < ActiveRecord::Base
   
   
   validates_numericality_of :post_id, {:allow_nil=>true}
-  validates_numericality_of :id
 end
 

data/spec/functional/expected/post.rb

@@ -7,6 +7,5 @@ class Post < ActiveRecord::Base
   # Constraints
   
   
-  validates_numericality_of :id
 end
 

data/spec/legacy_data/schema_spec.rb

@@ -112,17 +112,21 @@ describe LegacyData::Schema do
 
     describe 'constraints' do
       it 'should have the different types of constraints' do
-        @schema.stub!(:uniqueness_constraints  ).and_return([unique          =[mock], multi_column_unique=[mock]])
-        @schema.stub!(:presence_constraints    ).and_return([boolean_presence=[mock], presence_of        =[mock]])
-        @schema.stub!(:numericality_constraints).and_return(numericality={}                                      )
-        @schema.stub!(:custom_constraints      ).and_return(custom          =[mock])
-
-        @schema.constraints.should == {:unique             =>unique,
-                                       :multi_column_unique=>multi_column_unique,
-                                       :boolean_presence   =>boolean_presence,
-                                       :presence_of        =>presence_of,
-                                       :numericality_of    =>numericality,
-                                       :custom             =>custom }
+        @schema.stub!(:uniqueness_constraints  ).and_return([unique           =[mock], multi_column_unique=[mock]])
+        @schema.stub!(:presence_constraints    ).and_return([[boolean_presence=mock], presence_of        =[mock]])
+        @schema.stub!(:numericality_constraints).and_return(numericality      ={}                                 )
+        @schema.stub!(:custom_constraints      ).and_return([custom           =[mock], custom_inclusion   ={}    ])
+
+        constraints = @schema.constraints
+        
+        constraints[:unique             ].should == unique
+        constraints[:multi_column_unique].should == multi_column_unique
+        constraints[:presence_of        ].should == presence_of
+        constraints[:numericality_of    ].should == numericality
+        constraints[:custom             ].should == custom
+        constraints[:inclusion_of       ].should == custom_inclusion.merge(boolean_presence=> "true, false")
+
+
       end
 
       it 'should have the uniqueness constraints (booleans are done differently)' do
@@ -165,11 +169,40 @@ describe LegacyData::Schema do
         @schema.custom_constraints.should == []
       end
   
-      it 'should get all "belongs_to" relationships when a foreign key is in my table' do
-        @connection.should_receive(:respond_to?).with(:constraints).and_return(true)
-        @connection.should_receive(:constraints).and_return([['SomeConstraint', 'custom sql 1'], ['anotherconstraint', 'more custom sql']])
-        @schema.custom_constraints.should == {:some_constraint => 'custom sql 1', :anotherconstraint => 'more custom sql'}
+      describe 'custom constraints' do
+        before :each do
+          @connection.should_receive(:respond_to?).with(:constraints).and_return(true)
+        end
+
+        it 'should get all custom constraints on a table (this may only apply to oracle?)' do
+          @connection.should_receive(:constraints).and_return([['SomeConstraint',    %{custom sql 1}   ], 
+                                                               ['in_constraint',     %{SOMEColumn IN ('Y', 'N')}],
+                                                               ['anotherconstraint', %{"aColumn" IN ('Yes', 'No')}],
+                                                               ['anotherconstraint', %{more custom sql}],
+                                                               ])
+          custom_constraints = @schema.custom_constraints
+        
+          custom_constraints.first.should  == {:some_constraint => 'custom sql 1', :anotherconstraint => 'more custom sql'}
+          custom_constraints.second.should == {:acolumn         => "'Yes', 'No'",  :somecolumn        => "'Y', 'N'"}
+        end
+      
+        it 'should parse inclusion constraints out of custom constraints' do
+          @connection.should_receive(:constraints).and_return([['in_constraint',              %{SOMEColumn IN ('Y', 'N')}              ],
+                                                               ['with_white_space',           %{    SOMEColumn2   IN     ('Y', 'N')   }],
+                                                               ['with_quotes',                %{"aColumn" IN ('Yes', 'No')}            ],
+                                                               ['with_quotes_and_whitespace', %{   "aColumn2"    IN    ('Yes', 'No')  }]
+                                                              ])
+          custom_constraints = @schema.custom_constraints
+        
+          custom_constraints.first.should  == {}
+          custom_constraints.second.should == {:somecolumn        => "'Y', 'N'"   ,
+                                               :somecolumn2       => "'Y', 'N'"   ,
+                                               :acolumn           => "'Yes', 'No'",  
+                                               :acolumn2          => "'Yes', 'No'"
+                                               }
+        end
       end
+
     end  
   end
   

data/spec/models_from_tables_generator_spec.rb

@@ -24,7 +24,7 @@ describe 'Models From Tables generator' do
                                                                },
                                               :constraints  => { :unique             =>['title'],
                                                                  :multi_column_unique=>[],
-                                                                 :boolean_presence   =>[],
+                                                                 :inclusion_of       =>[],
                                                                  :presence_of        =>['body'],
                                                                  :numericality_of    =>[],
                                                                  :custom             =>[]
@@ -37,7 +37,8 @@ describe 'Models From Tables generator' do
     LegacyData::TableClassNameMapper.stub!(:class_name_for).with('posts'   ).and_return('Post')
     LegacyData::TableClassNameMapper.stub!(:class_name_for).with('comments').and_return('Comment')
 
-    invoke_generator('models_from_tables', ["--table-name", "posts"], :create)
+    cmd = command_for_generator('models_from_tables', ["--table-name", "posts"], :create)
+    cmd.invoke!
   end
   
   it 'should generate a posts model' do

data/spec/spec_helper.rb

@@ -46,10 +46,15 @@ def load_generator(generator_name="models_from_tables", args=[])
                                   {:generator=>generator_name, :command=>:create, :destination=>RAILS_ROOT})    
 end
 
-def invoke_generator(generator_name, args, the_command= :create)
+def command_for_generator(generator_name, args, the_command= :create)
   generator = load_generator(generator_name, args)
   LegacyData::TableClassNameMapper.stub!(:log)    
   cmd = generator.command(the_command)
   cmd.stub!(:logger).and_return(stub('stub').as_null_object)
+  cmd
+end
+
+def invoke_generator(generator_name, args, the_command= :create)
+  cmd = command_for_generator(generator_name, args, the_command)
   cmd.invoke!
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: legacy_data
 version: !ruby/object:Gem::Version 
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors: 
 - Alex Rothenberg
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-13 00:00:00 -04:00
+date: 2009-10-14 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency