citier 0.1.9

data/Manifest

@@ -0,0 +1,10 @@
+Rakefile
+lib/citier.rb
+lib/citier/acts_as_citier.rb
+lib/citier/child_instance_methods.rb
+lib/citier/class_methods.rb
+lib/citier/core_ext.rb
+lib/citier/instance_methods.rb
+lib/citier/root_instance_methods.rb
+lib/citier/sql_adapters.rb
+Manifest

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new('citier', '0.1.9') do |p|
+  p.description    = "CITIER (Class Inheritance & Table Inheritance Embeddings for Rails) is a solution for single and multiple class table inheritance.
+    For full information: http://peterhamilton.github.com/citier/
+    For the original version by ALTRABio see www.github.com/altrabio/"
+  p.url            = "https://github.com/peterhamilton/citier/"
+  p.author         = "Peter Hamilton, Original Authors - Laurent Buffat, Pierre-Emmanuel Jouve & "
+  p.email          = "peter@inspiredpixel.net"
+  p.ignore_pattern = ["tmp/*", "script/*", 'doc/*']
+  p.development_dependencies = []
+end

data/citier.gemspec

@@ -0,0 +1,44 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{citier}
+  s.version = "0.1.9"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Peter Hamilton, Originally from Laurent Buffat, Pierre-Emmanuel Jouve"]
+  s.date = %q{2011-04-29}
+  s.description = %q{CITIER (Class Inheritance & Table Inheritance Embeddings for Rails) is a solution for single and multiple class table inheritance.
+    For full information: http://peterhamilton.github.com/citier/
+    For the original version by ALTRABio see www.github.com/altrabio/}
+  s.email = %q{peter@inspiredpixel.net}
+  s.extra_rdoc_files = ["lib/citier.rb",
+    "lib/citier/acts_as_citier.rb",
+    "lib/citier/core_ext.rb",
+    "lib/citier/class_methods.rb",
+    "lib/citier/instance_methods.rb",
+    "lib/citier/child_instance_methods.rb",
+    "lib/citier/root_instance_methods.rb",
+    "lib/citier/sql_adapters.rb"]
+  s.files = ["Rakefile",
+    "lib/citier.rb",
+    "lib/citier/acts_as_citier.rb",
+    "lib/citier/core_ext.rb",
+    "lib/citier/class_methods.rb",
+    "lib/citier/instance_methods.rb",
+    "lib/citier/child_instance_methods.rb",
+    "lib/citier/root_instance_methods.rb",
+    "lib/citier/sql_adapters.rb",
+    "Manifest",
+    "citier.gemspec"]
+  s.homepage = %q{https://github.com/peterhamilton/citier/}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "citier", "--main", "README"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{citier}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = s.description
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+  end
+end

data/lib/citier.rb

@@ -0,0 +1,27 @@
+CITIER_DEBUGGING = (::Rails.env == 'development')
+
+def citier_debug(s)
+  if CITIER_DEBUGGING
+    puts "citier -> " + s
+  end
+end
+
+require 'citier/core_ext'
+
+# Methods which will be used by the class
+require 'citier/class_methods'
+
+# Methods that will be used for the instances of the Non Root Classes
+require 'citier/instance_methods'
+
+# Methods that will be used for the instances of the Root Classes
+require 'citier/root_instance_methods'
+
+# Methods that will be used for the instances of the Non Root Classes
+require 'citier/child_instance_methods'
+
+# Require SQL Adapters
+require 'citier/sql_adapters'
+
+#Require acts_as_citier hook
+require 'citier/acts_as_citier'

data/lib/citier/acts_as_citier.rb

@@ -0,0 +1,8 @@
+module Citier
+  def self.included(base) 
+    # When a class includes a module the module’s self.included method will be invoked.
+    base.send :extend, ClassMethods
+  end
+end
+
+ActiveRecord::Base.send :include, Citier

data/lib/citier/child_instance_methods.rb

@@ -0,0 +1,51 @@
+module ChildInstanceMethods
+
+  def save
+
+    #get the attributes of the class which are inherited from it's parent.
+    attributes_for_parent = self.attributes.reject{|key,value| !self.class.superclass.column_names.include?(key) }
+
+    # Get the attributes of the class which are unique to this class and not inherited.
+    attributes_for_current = self.attributes.reject{|key,value| self.class.superclass.column_names.include?(key) }
+
+    citier_debug("Attributes for #{self.class.to_s}: #{attributes_for_current.inspect.to_s}")
+
+    #create a new instance of the superclass, passing the inherited attributes.
+    parent = self.class.superclass.new(attributes_for_parent)
+    parent.id = self.id
+
+    parent.is_new_record(new_record?)
+
+    parent_saved = parent.save
+    self.id = parent.id
+
+    if(parent_saved==false)
+      # Couldn't save parent class
+      # TODO: Handle situation where parent class could not be saved
+      citier_debug("Class (#{self.class.superclass.to_s}) could not be saved")
+    end
+
+    # If there are attributes for the current class (unique & not inherited) 
+    # and parent(s) saved successfully, save current model
+    if(!attributes_for_current.empty? && parent_saved)
+      current = self.class::Writable.new(attributes_for_current)
+      current.is_new_record(new_record?)
+      current_saved = current.save
+      
+      # This is no longer a new record
+      is_new_record(false)
+
+      if(!current_saved)
+        citier_debug("Class (#{self.class.superclass.to_s}) could not be saved")
+      end
+    end
+
+    # Update root class with this 'type'
+    sql = "UPDATE #{self.class.root_class.table_name} SET #{self.class.inheritance_column} = '#{self.class.to_s}' WHERE id = #{self.id}"
+    citier_debug("SQL : #{sql}")
+    self.connection.execute(sql)
+    return parent_saved && current_saved
+  end
+
+  include InstanceMethods
+end

data/lib/citier/class_methods.rb

@@ -0,0 +1,77 @@
+module ClassMethods
+  # any method placed here will apply to classes
+
+
+  def acts_as_citier(options = {})
+
+    # Option for setting the inheritance columns, default value = 'type'
+    db_type_field = (options[:db_type_field] || :type).to_s
+
+    #:table_name = option for setting the name of the current class table_name, default value = 'tableized(current class name)'
+    table_name = (options[:table_name] || self.name.tableize.gsub(/\//,'_')).to_s
+
+    set_inheritance_column "#{db_type_field}"
+
+    if(self.superclass!=ActiveRecord::Base)
+      # Non root-class
+
+      citier_debug("Non Root Class")
+      citier_debug("table_name -> #{table_name}")
+
+      # Set up the table which contains ALL attributes we want for this class
+      set_table_name "view_#{table_name}"
+
+      citier_debug("tablename (view) -> #{self.table_name}")
+
+      # The the Writable. References the write-able table for the class because
+      # save operations etc can't take place on the views
+      self.const_set("Writable", create_class_writable(self))
+
+      # Add the functions required for children only
+      send :include, ChildInstanceMethods
+    else
+      # Root class
+
+      after_save :updatetype
+
+      citier_debug("Root Class")
+
+      set_table_name "#{table_name}"
+
+      citier_debug("table_name -> #{self.table_name}")
+
+      #returns the root class (the highest inherited class before ActiveRecord) 
+      def self.root_class
+        if(self.superclass!=ActiveRecord::Base)  
+          self.superclass.root_class
+        else
+          return self 
+        end
+      end
+
+      def self.find(*args) #overrides find to get all attributes  
+        tuples = super
+
+        # in case of many objects, return an array of them, reloaded to pull in inherited attributes
+        return tuples.map{|x| x.reload} if tuples.kind_of?(Array)
+
+        # in case of only one tuple, return it reloaded.
+        # Can't use reload as would loop inifinitely, so do a search by id instead.
+        # Probably a nice way of cleaning this a bit
+        return tuples.class.where(tuples.class[:id].eq(tuples.id))[0]
+      end
+
+      # Unlike destroy_all it 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 calls specific SQL requests.
+      # To be even more precise call delete_all with special conditions
+      def self.delete_all
+        #call delete method for each instance of the class
+        self.all.each{|o| o.delete }
+      end
+
+      # Add the functions required for root classes only
+      send :include, RootInstanceMethods
+    end
+  end
+end  

data/lib/citier/core_ext.rb

@@ -0,0 +1,49 @@
+class ActiveRecord::Base  
+
+  def self.[](column_name) 
+    arel_table[column_name]
+  end
+
+  def is_new_record(state)
+    @new_record = state
+  end
+  
+  def self.all(*args)
+    # For some reason need to override this so it uses my modified find function which reloads each object to pull in all properties.
+    return find(:all, *args)
+  end
+
+  def self.create_class_writable(class_reference)  #creation of a new class which inherits from ActiveRecord::Base
+    Class.new(ActiveRecord::Base) do
+      t_name = class_reference.table_name
+      t_name = t_name[5..t_name.length]
+
+      if t_name[0..5] == "view_"
+        t_name = t_name[5..t_name.length]
+      end
+
+      # set the name of the table associated to this class
+      # this class will be associated to the writable table of the class_reference class
+      set_table_name(t_name)
+    end
+  end
+end
+
+def create_citier_view(theclass)  #function for creating views for migrations 
+  self_columns = theclass::Writable.column_names.select{ |c| c != "id" }
+  parent_columns = theclass.superclass.column_names.select{ |c| c != "id" }
+  columns = parent_columns+self_columns
+  self_read_table = theclass.table_name
+  self_write_table = theclass::Writable.table_name
+  parent_read_table = theclass.superclass.table_name
+  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" 
+  citier_debug("Creating citier view -> #{sql}")
+  theclass.connection.execute sql
+end
+
+def drop_citier_view(theclass) #function for dropping views for migrations 
+  self_read_table = theclass.table_name
+  sql = "DROP VIEW #{self_read_table}"
+  citier_debug("Dropping citier view -> #{sql}")
+  theclass.connection.execute sql
+end

data/lib/citier/instance_methods.rb

@@ -0,0 +1,30 @@
+module InstanceMethods
+
+  # Delete the model (and all parents it inherits from if applicable)
+  def delete(id = self.id)
+    citier_debug("Deleting #{self.class.to_s} with ID #{self.id}")
+
+    # Delete information stored in the table associated to the class of the object
+    # (if there is such a table)
+    deleted = true
+    c = self.class
+    while c.superclass!=ActiveRecord::Base
+      citier_debug("Deleting back up hierarchy #{c}")
+      deleted &= c::Writable.delete(id)
+      c = c.superclass
+    end
+    deleted &= c.delete(id)
+    return deleted
+  end
+
+  def updatetype        
+    sql = "UPDATE #{self.class.root_class.table_name} SET #{self.class.inheritance_column} = '#{self.class.to_s}' WHERE id = #{self.id}"
+    self.connection.execute(sql)
+    citier_debug("#{sql}")
+  end
+
+  def destroy
+    return self.delete
+  end
+
+end

data/lib/citier/root_instance_methods.rb

@@ -0,0 +1,5 @@
+module RootInstanceMethods
+
+  include InstanceMethods
+
+end

data/lib/citier/sql_adapters.rb

@@ -0,0 +1,131 @@
+#------------------------------------------------------------------------------------------------#
+#                                                                                                #
+#       Modifications for SQL Adapters : needed to take views into account                       #
+#       (only SQLite, PostGreSQL & MySQL have been considered)                                   #
+#                                                                                                #
+#------------------------------------------------------------------------------------------------#
+
+# 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
+
+
+# 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
+
+
+
+# MySQL
+# No Modification needed, this essentially comes from the fact that MySQL "show" command
+# lists simultaneously tables & views

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: citier
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 9
+  version: 0.1.9
+platform: ruby
+authors: 
+- Peter Hamilton, Originally from Laurent Buffat, Pierre-Emmanuel Jouve
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-29 00:00:00 Z
+dependencies: []
+
+description: |-
+  CITIER (Class Inheritance & Table Inheritance Embeddings for Rails) is a solution for single and multiple class table inheritance.
+      For full information: http://peterhamilton.github.com/citier/
+      For the original version by ALTRABio see www.github.com/altrabio/
+email: peter@inspiredpixel.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- lib/citier.rb
+- lib/citier/acts_as_citier.rb
+- lib/citier/core_ext.rb
+- lib/citier/class_methods.rb
+- lib/citier/instance_methods.rb
+- lib/citier/child_instance_methods.rb
+- lib/citier/root_instance_methods.rb
+- lib/citier/sql_adapters.rb
+files: 
+- Rakefile
+- lib/citier.rb
+- lib/citier/acts_as_citier.rb
+- lib/citier/core_ext.rb
+- lib/citier/class_methods.rb
+- lib/citier/instance_methods.rb
+- lib/citier/child_instance_methods.rb
+- lib/citier/root_instance_methods.rb
+- lib/citier/sql_adapters.rb
+- Manifest
+- citier.gemspec
+homepage: https://github.com/peterhamilton/citier/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- citier
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 11
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: citier
+rubygems_version: 1.7.2
+signing_key: 
+specification_version: 3
+summary: "CITIER (Class Inheritance & Table Inheritance Embeddings for Rails) is a solution for single and multiple class table inheritance. For full information: http://peterhamilton.github.com/citier/ For the original version by ALTRABio see www.github.com/altrabio/"
+test_files: []
+