CITIEsForRAILS 0.0.3

data/CITIEsForRAILS.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{CITIEsForRAILS}
+  s.version = "0.0.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Laurent Buffat & Pierre-Emmanuel JOUVE"]
+  s.date = %q{2011-02-15}
+  s.description = %q{CITIEsForRAILS (Class Inheritance & Table Iheritance Embeddings For RAILS) is a solution that extends Single/Multiple/Class Table Inheritance. This solution is based on classical Ruby class inheritance, single table inheritance as well as DB views.
+
+
+  For Full Information GO TO : http://altrabio.github.com/CITIEsForRAILS/}
+  s.email = %q{citiesforrails @nospam@ gmail.com}
+  s.extra_rdoc_files = ["lib/citiesforrails.rb", "lib/citiesforrails/acts_as_cities.rb", "lib/citiesforrails/core_ext.rb"]
+  s.files = ["Rakefile", "lib/citiesforrails.rb", "lib/citiesforrails/acts_as_cities.rb", "lib/citiesforrails/core_ext.rb", "Manifest", "CITIEsForRAILS.gemspec"]
+  s.homepage = %q{https://github.com/altrabio/CITIEsForRAILS}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "CITIEsForRAILS", "--main", "README"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{citiesforrails}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{CITIEsForRAILS (Class Inheritance & Table Iheritance Embeddings For RAILS) is a solution that extends Single/Multiple/Class Table Inheritance. This solution is based on classical Ruby class inheritance, single table inheritance as well as DB views.   For Full Information GO TO : http://altrabio.github.com/CITIEsForRAILS/}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/Manifest

@@ -0,0 +1,5 @@
+Rakefile
+lib/citiesforrails.rb
+lib/citiesforrails/acts_as_cities.rb
+lib/citiesforrails/core_ext.rb
+Manifest

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new('CITIEsForRAILS', '0.0.3') do |p|
+  p.description    = "CITIEsForRAILS (Class Inheritance & Table Iheritance Embeddings For RAILS) is a solution that extends Single/Multiple/Class Table Inheritance. This solution is based on classical Ruby class inheritance, single table inheritance as well as DB views.
+
+
+  For Full Information GO TO : http://altrabio.github.com/CITIEsForRAILS/"
+  p.url            = "https://github.com/altrabio/CITIEsForRAILS"
+  p.author         = "Laurent Buffat & Pierre-Emmanuel JOUVE"
+  p.email          = "citiesforrails @nospam@ gmail.com"
+  p.ignore_pattern = ["tmp/*", "script/*"]
+  p.development_dependencies = []
+end

data/lib/citiesforrails/acts_as_cities.rb

@@ -0,0 +1,325 @@
+module Cities
+  
+  def self.included(base) 
+    #When a class includes a module the module’s self.included method will be invoked.
+    base.send :extend, ClassMethods
+  end
+
+ 
+#------------------------------------------------------------------------------------------------------------------------ 
+#
+#             methods that will be used for the class
+#
+#------------------------------------------------------------------------------------------------------------------------
+
+  module ClassMethods
+    # any method placed here will apply to classes
+    
+
+    def acts_as_cities(options = {}) #options hash see below
+        
+        
+        db_type_field = (options[:db_type_field] || :type).to_s         #:db_type_field = option for setting the inheritance columns, default value = 'type'
+        table_name = (options[:table_name] || self.name.tableize.gsub(/\//,'_')).to_s  #:table_name = option for setting the name of the current class table_name, default value = 'tableized(current class name)'
+
+        set_inheritance_column "#{db_type_field}"
+
+        if(self.superclass!=ActiveRecord::Base)
+          #------------------------------------------------------------------------------------------------------------------------ 
+          #
+          #             methods that will be used for the NON mother class
+          #
+          #------------------------------------------------------------------------------------------------------------------------
+          puts "acts_as_cities -> NON mother class"
+    
+          set_table_name "view_#{table_name}"
+          aaa=create_class_part_of self# these 2 lines are there for the creation of class PartOf (which is a class of the current class)
+          self.const_set("PartOf",aaa) # it will stand for the write table of the current class            
+          
+          
+          
+           def self.delete(id) #overrides delete to delete every pieces of information about this record wherever it may be stored
+              if RAILS_ENV == 'development' 
+                puts "delete de classe = #{self.name}"
+              end
+              return self.delete(id) if self == self.mother_class #if the class of the record is the mother class then call with the id of the object
+                                                                #if the class of the record is not the mother class then 
+              if RAILS_ENV == 'development' 
+                puts "2->delete de classe = #{self.name}"
+              end
+
+              if self.respond_to?('has_a_part_of?') # eventually delete pieces of information stored in the table associated to the class of the object (if there is such a table)
+                if self.has_a_part_of?  && (self.superclass==self.mother_class || self::PartOf!=self.superclass::PartOf) #SHOW TO LB implique moins de SQL
+                  if RAILS_ENV == 'development' 
+                    puts("has a part of")
+                  end
+                  self::PartOf.delete(id)
+                else
+                  if RAILS_ENV == 'development' 
+                    puts "no part of" 
+                  end
+                end 
+              end
+
+              if RAILS_ENV == 'development' 
+                puts "3->delete de classe = #{self.name}"
+              end
+
+              self.superclass.delete(id)                     # call the delete method associated to the super class of the current class with the id the object
+           end  
+            
+          
+              send :include, InstanceMethods1              
+        else
+          #------------------------------------------------------------------------------------------------------------------------ 
+          #
+          #             methods that will be used for the mother class
+          #
+          #------------------------------------------------------------------------------------------------------------------------
+          after_save :updatetype
+         
+          
+          if RAILS_ENV == 'development' 
+            puts "acts_as_cities -> MOTHER class"        
+          end
+          set_table_name="#{table_name}"     
+          
+          def self.mother_class #returns the mother class (the highest inherited class before ActiveRecord) 
+           if(self.superclass!=ActiveRecord::Base)  
+              self.superclass.mother_class
+            else
+            return self 
+            end
+          end 
+
+
+
+          def self.find(*args) #overrides find to get more informations   
+            
+            tuples = super
+            return tuples if tuples.kind_of?(Array) # in case of several tuples just return the tuples as they are
+            #tuples.reload2                         # reload2 is defined in lib/activerecord_ext.rb
+            tuples.class.where(tuples.class[:id].eq(tuples.id))[0]  # in case of only one tuple return a reloaded tuple  based on the class of this tuple
+                                                                    # this imply a "full" load of the tuple
+                                                                    # A VOIR AVEC LB peut être préfère t il laisser reload2                                                        
+          end
+
+
+          def self.delete_all #contrary to destroy_all this is useful to override this method : In fact destroy_all will explicitly call a destroy method on each object
+                              #whereas delete_all doesn't and only call a specific SQL request
+                              # (to be even more precise delete explictly call delete_all with special conditions )
+            
+            self.all.each{|o| o.delete } #call delete method for each instance of the class
+            
+          end
+          
+      
+                   
+          send :include, InstanceMethods
+        end
+        
+        
+
+    end
+  
+  end  
+ 
+#------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ 
+ 
+ 
+ 
+ 
+ 
+#------------------------------------------------------------------------------------------------------------------------
+# 
+#                 methods that will be used for the instances of the Non Mother Classes
+#
+#------------------------------------------------------------------------------------------------------------------------ 
+
+    module InstanceMethods1
+ 
+      def save
+
+    
+        attributes_for_super = self.attributes.select{|key,value| self.class.superclass.column_names.include?(key) } #get the attributes of the class of the instance that also belong to its superclass 
+        attributes_for_part_of = self.attributes.select{|key,value| !self.class.superclass.column_names.include?(key) } #get the attributes of the class of the instance that do not belong to its superclass
+                                                                                                                        # these pieces of information should be stored in the table associated to the class of the instance
+        herited = self.class.superclass.new(attributes_for_super)   #create a new instance of the superclass of the considered instance (self) 
+        if(!new_record?)
+            herited.swap_new_record
+            herited.id = self.id
+        end
+
+        if(herited.class==herited.class.mother_class)
+          herited_saved = herited.save # save the new instance (by calling its save method)      
+        else
+          herited_saved = herited.saveBis # save the new instance (by calling its save method)      
+        end
+    
+        if(herited_saved==false) 
+          alert('please contact us') # que faire si herited_saved vaut false ? A VOIR
+        end
+
+        part_of_saved=true
+        if( ! attributes_for_part_of.empty? ) #if there are some pieces of information to save in the table associated to the class of the considered instance
+          part_of = self.class::PartOf.new(attributes_for_part_of) 
+          part_of.id = herited.id
+
+          if(!new_record?)
+            part_of.swap_new_record
+          end
+
+          part_of_saved = part_of.save
+          if(part_of_saved==false) 
+            alert('please contact us...') # que faire si herited_saved vaut false ? A VOIR
+          end
+         end
+
+
+        self.id = herited.id
+    
+        sql = "UPDATE #{self.class.mother_class.table_name} SET #{self.class.inheritance_column} = '#{self.class.to_s}' WHERE id = #{self.id}"
+        if RAILS_ENV == 'development' 
+          puts "SQL : #{sql}"
+        end
+        self.connection.execute(sql)
+        return herited_saved && part_of_saved
+      end
+
+
+
+      def saveBis
+
+
+        attributes_for_super = self.attributes.select{|key,value| self.class.superclass.column_names.include?(key) } #get the attributes of the class of the instance that also belong to its superclass 
+        attributes_for_part_of = self.attributes.select{|key,value| !self.class.superclass.column_names.include?(key) } #get the attributes of the class of the instance that do not belong to its superclass
+                                                                                                                        # these pieces of information should be stored in the table associated to the class of the instance
+        herited = self.class.superclass.new(attributes_for_super)   #create a new instance of the superclass of the considered instance (self) 
+        if(!new_record?)
+            herited.swap_new_record
+            herited.id = self.id
+        end
+
+
+        if(herited.class==herited.class.mother_class)
+            herited_saved = herited.save # save the new instance (by calling its save method)      
+        else
+            herited_saved = herited.saveBis # save the new instance (by calling its save method)      
+        end
+
+        if(herited_saved==false) 
+          alert('please contact altrabio use the following mail : altrabio...altrabio.com') # que faire si herited_saved vaut false ? A VOIR
+        end
+
+        part_of_saved=true
+        if( ! attributes_for_part_of.empty? ) #if there are some piecesof information to save in the table associated to the class of the cosidered instance
+          part_of = self.class::PartOf.new(attributes_for_part_of) #
+          part_of.id = herited.id
+
+          if(!new_record?)
+            part_of.swap_new_record
+          end
+
+          part_of_saved = part_of.save
+          if(part_of_saved==false) 
+            alert('please contact altrabio use the following mail : altrabio...altrabio.com') # que faire si herited_saved vaut false ? A VOIR
+          end
+         end
+
+
+        self.id = herited.id
+
+        return herited_saved && part_of_saved
+      end
+
+      def delete   #call the class delete method with the id of the instance
+         if RAILS_ENV == 'development' 
+           puts("1-> delete d'instance #{self.id} la classe est #{self.class.name}")
+         end
+         self.class.delete( self.id)
+
+         if RAILS_ENV == 'development' 
+           puts("wl1")
+         end
+     end
+
+    end
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+    #------------------------------------------------------------------------------------------------------------------------
+    # 
+    #                 methods that will be used for the instances of the Mother Class
+    #
+    #------------------------------------------------------------------------------------------------------------------------ 
+ 
+    module InstanceMethods
+ 
+
+      def updatetype        
+          sql = "UPDATE #{self.class.mother_class.table_name} SET #{self.class.inheritance_column} = '#{self.class.to_s}' WHERE id = #{self.id}"
+          self.connection.execute(sql)
+          puts"#{sql}"      
+      end
+  
+      def destroy
+          super
+          if self.class.respond_to?('has_a_part_of?')
+            qdestroy
+          else
+            return self
+          end
+      end
+  
+      def qdestroy
+          xxx=self.class
+          qqq=xxx
+
+          while xxx!=ActiveRecord::Base do
+ 
+            if xxx.respond_to?('has_a_part_of?') # eventually delete pieces of information stored in the write tables associated to the current xxx class for the object (if there is such a table)
+
+              if (xxx.superclass==xxx.mother_class || xxx::PartOf!=xxx.superclass::PartOf)
+
+                puts "partof for class = #{xxx.name}"
+                xxx::PartOf.destroy(self.id)
+                #oo=xxx::PartOf.find(self.id)
+                #oo.destroy
+
+              else           
+                  puts "no part of for class = #{xxx.name}"                 
+              end#partof
+          end #respond
+          
+          qqq=xxx
+          xxx=xxx.superclass
+
+          end #while
+
+          puts "#{qqq.name} should be the mother class"          
+          qqq.delete(self.id) #delete information into the table of the mother class
+
+          return self
+      end  
+   
+        
+   
+  
+    end  
+  
+  
+  
+  
+  
+end  
+  ActiveRecord::Base.send :include, Cities 
+  
+

data/lib/citiesforrails/core_ext.rb

@@ -0,0 +1,282 @@
+
+
+
+
+
+#------------------------------------------------------------------------------------------------#
+#                                                                                                #
+#       Modifications for ActiveRecord                                                           #
+#                                                                                                #
+#------------------------------------------------------------------------------------------------#
+
+ class ActiveRecord::Base  
+
+   def reload 
+     self.class.find(self.id)
+   end
+
+   def self.[](column_name) 
+     arel_table[column_name]
+   end
+   
+   def swap_new_record # a new own method to arbitrary change the value of the @persisted instance variable
+                       # (this instance variable is a flag which indicates if a record is a new one or not)
+        @persisted=!@persisted
+        puts "not persisted"
+   end
+
+      
+   def self.create_class_part_of(class_reference)  #creation of a new class which inherits from ActiveRecord::Base
+
+     def class_reference.has_a_part_of?
+       return true
+     end
+
+     Class.new(ActiveRecord::Base) do
+       a=class_reference.table_name
+       b=a[5..a.length]
+       set_table_name(b)#set the name of the table associated to this class
+                        # this class will be associated to the write table of the class_reference class
+                        # consequently the name of the table is the name of the read table without "view_" 
+
+     end     
+   end
+
+
+ end
+ 
+
+
+
+
+
+
+
+ #------------------------------------------------------------------------------------------------#
+ #                                                                                                #
+ #       Modifications for ActiveRecord::Persistence                                              #
+ #                                                                                                #
+ #------------------------------------------------------------------------------------------------#
+
+ module ActiveRecord
+   
+   module Persistence
+
+     def destroy
+   
+       if persisted?     
+         if (self.class.respond_to?("mother_class"))&&(self.class.table_name[0]=="v" && self.class.table_name[1]=="i" && self.class.table_name[2]=="e" && self.class.table_name[3]=="w" && self.class.table_name[4]=="_")
+           #if the class of the object is based on this gem and if the considered table is a view
+           puts"modified version of ActiveRecord::Persistence destroy"       
+           puts "class = #{self.class.name} table name=#{self.class.table_name} this is a view : skipping some instructions"
+         else
+           puts"unmodified version of ActiveRecord::Persistence destroy"       
+           self.class.unscoped.where(self.class.arel_table[self.class.primary_key].eq(id)).delete_all
+         end
+       end
+
+       @destroyed = true
+
+       freeze
+     end
+  end
+end
+
+
+
+
+
+#-----------------------------------------------------------------------------------------------#
+#                                                                                               #
+#       Some functions to manage views creation & dropping                                        #
+#                                                                                               #
+#-----------------------------------------------------------------------------------------------#
+    def CreateTheViewForCITIEs(theclass)  #function for creating views for migrations 
+                                   
+           if RAILS_ENV == 'development'
+              puts "CreateTheView 1"
+           end
+           self_columns = theclass::PartOf.column_names.select{ |c| c != "id" } 
+           if RAILS_ENV == 'development' 
+             puts "CreateTheView 2"
+           end
+           parent_columns = theclass.superclass.column_names.select{ |c| c != "id" }
+           columns = parent_columns+self_columns
+           if RAILS_ENV == 'development' 
+             puts "CreateTheView 3"
+           end
+           self_read_table = theclass.table_name
+           # eventuellement warning si pas de part_of
+           self_write_table = theclass::PartOf.table_name
+           parent_read_table = theclass.superclass.table_name
+           if RAILS_ENV == 'development' 
+             puts "CreateTheView 4"
+            end
+       
+           if RAILS_ENV == 'development' 
+             puts " self read table #{self_read_table} | parent_read_table #{parent_read_table}"
+            end
+           sql = "CREATE VIEW #{self_read_table} AS SELECT #{parent_read_table}.id, #{columns.join(',')} FROM #{parent_read_table}, #{self_write_table} WHERE #{parent_read_table}.id = #{self_write_table}.id" 
+           theclass.connection.execute sql
+    end
+   
+    def DropTheViewForCITIEs(theclass) #function for dropping views for migrations 
+            if RAILS_ENV == 'development'
+               puts "1 DropTheViewForCITIEs"
+            end
+            self_read_table = theclass.table_name
+       
+            if RAILS_ENV == 'development' 
+              puts " DROP VIEW #{self_read_table}"
+            end
+            sql = "DROP VIEW #{self_read_table}" 
+            theclass.connection.execute sql
+    end
+
+
+    #------------------------------------------------------------------------------------------------#
+    #                                                                                                #
+    #       Modifications for SQL Adapters : needed to take views into account                       #
+    #       (only SQLite, PostGreSQL & MySQL has been considered)                                    #
+    #                                                                                                #
+    #------------------------------------------------------------------------------------------------#
+
+
+    #------------------------------------------------------------------------------------------------#
+    #       Modifications for SQL Adapters : SQLite                                                  #
+    #------------------------------------------------------------------------------------------------#
+    require 'active_record'
+    require 'active_record/connection_adapters/sqlite_adapter'
+    require 'active_record/connection_adapters/sqlite3_adapter'
+    require 'active_record/connection_adapters/postgresql_adapter'
+    module ActiveRecord
+      module ConnectionAdapters
+        class SQLiteAdapter < AbstractAdapter
+
+            def tables(name = nil) 
+              sql = <<-SQL
+                SELECT name
+                FROM sqlite_master
+                WHERE (type = 'table' or type='view') AND NOT name = 'sqlite_sequence'
+              SQL
+              # Modification : the where clause was intially WHERE type = 'table' AND NOT name = 'sqlite_sequence' 
+              #                now it is WHERE (type = 'table' or type='view') AND NOT name = 'sqlite_sequence'
+              # this modification is made to consider tables AND VIEWS as tables
+
+              execute(sql, name).map do |row|
+                row['name']
+              end
+            end
+         end
+        end
+
+    end
+
+
+    #------------------------------------------------------------------------------------------------#
+    #       Modifications for SQL Adapters : PostGreSQL                                              #
+    #------------------------------------------------------------------------------------------------#
+
+    
+   module ActiveRecord
+    module ConnectionAdapters
+     class PostgreSQLAdapter < AbstractAdapter
+        def tables(name = nil)
+          a=tablesL(name)
+          puts("1------>#{a}")        
+          b=viewsL(name)
+          if(b!=[])
+           a=a+b
+          end
+          puts("2------>#{a}")
+          return a
+        end
+
+        def tablesL(name = nil)
+
+          query(<<-SQL, name).map { |row| row[0] }
+            SELECT tablename
+            FROM pg_tables
+            WHERE schemaname = ANY (current_schemas(false))
+          SQL
+        end
+        def viewsL(name = nil)
+
+          query(<<-SQL, name).map { |row| row[0] }
+            SELECT viewname
+            FROM pg_views
+            WHERE schemaname = ANY (current_schemas(false))
+          SQL
+        end
+
+        def table_exists?(name)
+          a=table_existsB?(name)
+          b=views_existsB?(name)
+          puts"T---->#{a}"
+          puts"T---->#{b}"
+          return a||b
+        end
+
+
+        def table_existsB?(name)
+          name          = name.to_s
+          schema, table = name.split('.', 2)
+
+          unless table # A table was provided without a schema
+            table  = schema
+            schema = nil
+          end
+
+          if name =~ /^"/ # Handle quoted table names
+            table  = name
+            schema = nil
+          end
+
+          query(<<-SQL).first[0].to_i > 0
+              SELECT COUNT(*)
+              FROM pg_tables
+              WHERE tablename = '#{table.gsub(/(^"|"$)/,'')}'
+              #{schema ? "AND schemaname = '#{schema}'" : ''}
+          SQL
+
+        end
+        def views_existsB?(name)
+          name          = name.to_s
+          schema, table = name.split('.', 2)
+
+          unless table # A table was provided without a schema
+            table  = schema
+            schema = nil
+          end
+
+          if name =~ /^"/ # Handle quoted table names
+            table  = name
+            schema = nil
+          end
+
+          query(<<-SQL).first[0].to_i > 0
+              SELECT COUNT(*)
+              FROM pg_views
+              WHERE viewname = '#{table.gsub(/(^"|"$)/,'')}'
+              #{schema ? "AND schemaname = '#{schema}'" : ''}
+          SQL
+
+        end
+    end
+    end
+    end
+
+
+
+    #------------------------------------------------------------------------------------------------#
+    #       Modifications for SQL Adapters : MySQL                                                   #
+    #------------------------------------------------------------------------------------------------#
+
+    # No Modification needed, this essentially comes from the fact that MySQL "show" command
+    # lists simultaneously tables & views
+
+
+
+
+
+    #               -------------------------------------------------------------                     #

data/lib/citiesforrails.rb

@@ -0,0 +1,3 @@
+
+require 'citiesforrails/core_ext' 
+require 'citiesforrails/acts_as_cities'

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: CITIEsForRAILS
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- Laurent Buffat & Pierre-Emmanuel JOUVE
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-15 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: |-
+  CITIEsForRAILS (Class Inheritance & Table Iheritance Embeddings For RAILS) is a solution that extends Single/Multiple/Class Table Inheritance. This solution is based on classical Ruby class inheritance, single table inheritance as well as DB views.
+  
+  
+    For Full Information GO TO : http://altrabio.github.com/CITIEsForRAILS/
+email: citiesforrails @nospam@ gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- lib/citiesforrails.rb
+- lib/citiesforrails/acts_as_cities.rb
+- lib/citiesforrails/core_ext.rb
+files: 
+- Rakefile
+- lib/citiesforrails.rb
+- lib/citiesforrails/acts_as_cities.rb
+- lib/citiesforrails/core_ext.rb
+- Manifest
+- CITIEsForRAILS.gemspec
+has_rdoc: true
+homepage: https://github.com/altrabio/CITIEsForRAILS
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- CITIEsForRAILS
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: citiesforrails
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: "CITIEsForRAILS (Class Inheritance & Table Iheritance Embeddings For RAILS) is a solution that extends Single/Multiple/Class Table Inheritance. This solution is based on classical Ruby class inheritance, single table inheritance as well as DB views.   For Full Information GO TO : http://altrabio.github.com/CITIEsForRAILS/"
+test_files: []
+