dm-reflection 0.10.2 → 0.11.0

data/.gitignore

@@ -17,7 +17,6 @@ tmtags
 coverage
 rdoc
 pkg
-*.gemspec
 
 ## PROJECT::SPECIFIC
 

data/VERSION

@@ -1 +1 @@
-0.10.2
+0.11.0

data/dm-reflection.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dm-reflection}
-  s.version = "0.10.2"
+  s.version = "0.11.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Martin Gamsjaeger (snusnu), Yogo Team"]
-  s.date = %q{2010-05-05}
+  s.date = %q{2010-06-09}
   s.description = %q{Generates datamapper models from existing database schemas and export them to files}
   s.email = %q{irjudson [a] gmail [d] com}
   s.extra_rdoc_files = [

data/lib/dm-reflection/adapters/mysql.rb

@@ -44,6 +44,10 @@ module DataMapper
         }[$1] || raise("unknown type: #{db_type}")
       end
 
+      def separator
+        '--'
+      end
+
       ##
       # Get the list of table names
       #
@@ -54,6 +58,23 @@ module DataMapper
         select("SHOW FULL TABLES FROM #{options[:path][1..-1]} WHERE Table_type = 'BASE TABLE'").map { |item| item.first }
       end
 
+      ##
+      # This method breaks the join table into the two other table names
+      #
+      # @param [String] Name join table name
+      # @return [String,String] The two other table names joined.
+      # 
+      def join_table_name(name, name_list=nil)
+        name_list = get_storage_names.sort if name_list.nil?
+        left = name_list[name_list.index(name)-1]
+        right = name[left.length+1..-1]
+        if name_list.include?(right)
+          return left,right
+        else
+          return nil,nil
+        end
+      end
+
       ##
       # Get the column specifications for a specific table
       #
@@ -65,8 +86,15 @@ module DataMapper
       #
       def get_properties(table)
         # TODO: use SHOW INDEXES to find out unique and non-unique indexes
+        join_table = false
+        columns = select("SHOW COLUMNS FROM #{table} IN #{options[:path][1..-1]};")
 
-        select("SHOW COLUMNS FROM #{table} IN #{options[:path][1..-1]};").map do |column|
+        if columns.length == 2 && columns[0].field.downcase[-3,3] == "_id" && columns[1].field.downcase[-3,3] == "_id"
+          left_table_name,right_table_name = join_table_name(table)
+          join_table = true
+        end
+        
+        columns.map do |column|
           type           = get_type(column.type)
           auto_increment = column.extra == 'auto_increment'
 
@@ -84,24 +112,35 @@ module DataMapper
             :key      => column.key == 'PRI',
           }
           
-          if type == Integer && field_name[-3,3] == "_id"
+          # TODO: use the naming convention to compare the name vs the column name
+          unless attribute[:name] == column.field
+            attribute[:field] = column.field
+          end
+          
+          if join_table
+            attribute[:type] = DataMapper::Associations::Relationship
+            attribute[:relationship] = {
+              # M:M requires we wire things a bit differently and remove the join model
+              :many_to_many => true,
+              :parent => Extlib::Inflection.classify(left_table_name), 
+              :child => Extlib::Inflection.classify(right_table_name), 
+              # When we can detect more from the database we can optimize this
+              :cardinality => Infinity, 
+              :bidirectional => true }      
+              return [attribute]      
+          elsif type == Integer && field_name[-3,3] == "_id"
             # This is a foriegn key. So this model belongs_to the other (_id) one.
             # Add a special set of values and flag this as a relationship so the reflection code
             # can rebuild the relationship when it's building the model.
             attribute[:type] = DataMapper::Associations::Relationship
             attribute[:relationship] = { 
+              :many_to_many => false,
               :parent => Extlib::Inflection.classify(field_name[0..-4]), 
               :child => Extlib::Inflection.classify(table), 
               # When we can detect more from the database we can optimize this
               :cardinality => Infinity, 
               :bidirectional => true }
           end
-          
-          # TODO: use the naming convention to compare the name vs the column name
-          unless attribute[:name] == column.field
-            attribute[:field] = column.field
-          end
-
           attribute
         end
       end

data/lib/dm-reflection/adapters/persevere.rb

@@ -15,12 +15,14 @@ module DataMapper
       #
       chainable do
         def get_type(db_type)
+          
+          return :has_one_relation if db_type.has_key?("$ref") 
+          
           type = db_type['type']
           format = db_type['format']
 
           case type
-          when Hash        then DataMapper::Types::JsonReference
-          when 'array'     then DataMapper::Types::JsonReferenceCollection
+          when 'array'     then :has_many_relation
           when 'serial'    then DataMapper::Types::Serial
           when 'integer'   then Integer
           # when 'number'    then BigDecimal
@@ -36,6 +38,11 @@ module DataMapper
           end
         end
       end
+      
+      def separator
+        '/'
+      end
+      
       ##
       # Get the list of schema names
       #
@@ -43,7 +50,7 @@ module DataMapper
       #
       def get_storage_names
         @schemas = self.get_schema
-        @schemas.map { |schema| schema['id'].gsub('/', '__') }
+        @schemas.map { |schema| schema['id'] }
       end
 
       ##
@@ -57,32 +64,34 @@ module DataMapper
       #
       chainable do
         def get_properties(table)
-          results = Array.new
-          schema = self.get_schema(table.gsub('__', '/'))[0]
+          attributes = Array.new
+          schema = self.get_schema(table)[0]
           schema['properties'].each_pair do |key, value|
             type = get_type(value)
-            property = {:name => key, :type => type }
-            property.merge!({ :required => !value.delete('optional'),
-                              :key => value.has_key?('index') && value.delete('index') }) unless property[:type] == DataMapper::Types::Serial
-                              
-            if type.kind_of?(DataMapper::Types::JsonReference)
-              property.merge!( {:reference => derive_relationship_model(value[:type]["$ref"])} )
-            end
             
-            if type.kind_of?(DataMapper::Types::JsonReferenceCollection)
-              property.merge!( {:reference => derive_relationship_model(value[:items]["$ref"])} )
-            end
+            attribute = { :name => key }
             
-            value.delete('type')
-            value.delete('format')
-            value.delete('unique')
-            value.delete('index')
-            value.delete('items')
-            value.keys.each { |key| value[key.to_sym] = value[key]; value.delete(key) }
-            property.merge!(value)
-            results << property
+            if type == :has_one_relation
+              # Has one
+              # Retrieve the other side to determine the cardinality
+              other_table = [table.split('/')[0..-2], value['$ref']].join("/")
+              other_schema = self.get_schema(other_table)[0]
+
+            elsif type == :has_many_relation
+              # Has many
+              # Retrieve the other side to determine the cardinality
+              other_table = [table.split('/')[0..-2], value['items']['$ref']].join("/")
+              other_schema = self.get_schema(other_table)[0]
+              
+            else
+              attribute.merge!({ :type => type, :required => !value.delete('optional'), :key => value.has_key?('index') && value.delete('index') }) unless attribute[:type] == DataMapper::Types::Serial
+              ['type', 'format', 'unique', 'index', 'items'].each { |key| value.delete(key) }
+              value.keys.each { |key| value[key.to_sym] = value[key]; value.delete(key) }
+              attribute.merge!(value)
+              attributes << attribute
+            end
           end
-          return results
+          return attributes
         end
       end
 

data/lib/dm-reflection/adapters/postgres.rb

@@ -29,6 +29,10 @@ module DataMapper
         }[db_type] || raise("unknown db type: #{db_type}")
       end
 
+      def separator
+        '--'
+      end
+
       ##
       # Get the list of table names
       #

data/lib/dm-reflection/adapters/sqlite3.rb

@@ -25,6 +25,10 @@ module DataMapper
           }[$1] || raise("unknown db type: #{db_type}")
       end
 
+      def separator
+        '--'
+      end
+
       ##
       # Get the list of table names
       #

data/lib/dm-reflection/reflection.rb

@@ -9,11 +9,11 @@ module DataMapper
     #
     def self.reflect(repository, namespace = Object, overwrite = false)
       adapter = DataMapper.repository(repository).adapter
-
+      separator = adapter.separator
       models  = Hash.new
 
       adapter.get_storage_names.each do |storage_name|
-        namespace_parts = storage_name.split('__').map do |part|
+        namespace_parts = storage_name.split(separator).map do |part|
           Extlib::Inflection.classify(part)
         end
 
@@ -43,14 +43,26 @@ module DataMapper
         models[model_name] = namespace.const_set(model_name, anonymous_model)
       end
 
-      models.values.each do |model|
+      join_models = Array.new
+      
+      models.each do |model_name, model|
         adapter.get_properties(model.storage_name).each do |attribute|
           if attribute[:type] == DataMapper::Associations::Relationship
             parent = models[attribute[:relationship][:parent]]
             child = models[attribute[:relationship][:child]]
-            child.belongs_to(parent.name.downcase.to_sym)
-            if attribute[:relationship][:bidirectional]
-              parent.has(attribute[:relationship][:cardinality], child.name.pluralize.downcase.to_sym)
+            if parent.nil? or child.nil?
+              puts "Reflection Relationship: P: #{parent.inspect} C: #{child.inspect} A: #{attribute[:relationship].inspect}"
+            end
+            if attribute[:relationship][:many_to_many]
+              parent.has(attribute[:relationship][:cardinality], child.name.tableize.pluralize.downcase.to_sym, :through => DataMapper::Resource, :model => child)
+              child.has(attribute[:relationship][:cardinality], parent.name.tableize.pluralize.downcase.to_sym, :through => DataMapper::Resource, :model => parent)
+              # Remove join model
+              join_models << model_name
+            else
+              child.belongs_to(parent.name.tableize.downcase.to_sym, :model => parent)
+              if attribute[:relationship][:bidirectional]
+                parent.has(attribute[:relationship][:cardinality], child.name.tableize.pluralize.downcase.to_sym, :model => child)
+              end
             end
           else
             attribute.delete_if { |k,v| v.nil? }
@@ -58,8 +70,13 @@ module DataMapper
           end
         end
       end
-        
-      models.to_a
+          
+      join_models.each do |model|
+        models.delete(model)
+        DataMapper::Model.descendants.delete(model)
+      end
+
+      models.values
     end
   end # module Reflection
 

data/spec/persevere_reflection_spec.rb

@@ -28,8 +28,6 @@ if ENV['ADAPTER'] == 'persevere'
     property :body, Text, :length => 65535, :lazy => true
     property :updated_at, DateTime
     property :score, Integer
-    property :blog_post, DataMapper::Types::JsonReference, :reference => :Post
-
 
   end
   RUBY
@@ -49,8 +47,6 @@ if ENV['ADAPTER'] == 'persevere'
         }
 
         @models.each_key { |model| Extlib::Inflection.constantize(model.to_s).auto_migrate! }
-        Post.send(:property, :comments, DataMapper::Types::JsonReferenceCollection, :reference => :PostComment)
-        Post.auto_upgrade!
         @models.each_key { |model| remove_model_from_memory( Extlib::Inflection.constantize(model.to_s) ) }
     end
     
@@ -75,12 +71,6 @@ if ENV['ADAPTER'] == 'persevere'
       result = @adapter.get_properties("post")
       result.should be_kind_of(Array)
     end
-    
-    it "should reflect out JsonReference types" do
-      DataMapper::Reflection.reflect(:default)
-      PostComment.properties[:blog_post].type.should eql DataMapper::Types::JsonReference
-      Post.properties[:comments].type.should eql DataMapper::Types::JsonReferenceCollection
-    end
 
   end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 10
-  - 2
-  version: 0.10.2
+  - 11
+  - 0
+  version: 0.11.0
 platform: ruby
 authors: 
 - Martin Gamsjaeger (snusnu), Yogo Team
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-05 00:00:00 -06:00
+date: 2010-06-09 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency