citier 0.1.12 → 0.1.13

data/Rakefile

@@ -2,7 +2,7 @@ require 'rubygems'
 require 'rake'
 require 'echoe'
 
-Echoe.new('citier', '0.1.12') do |p|
+Echoe.new('citier', '0.1.13') 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/"

data/citier.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{citier}
-  s.version = "0.1.12"
+  s.version = "0.1.13"
 
   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"]
@@ -36,6 +36,8 @@ Gem::Specification.new do |s|
   s.rubyforge_project = %q{citier}
   s.rubygems_version = %q{1.3.7}
   s.summary = s.description
+  
+  s.add_dependency('rails_sql_views') #needs the 'rails_sql_views', :git => 'git://github.com/morgz/rails_sql_views.git'  fork. Set this in your apps bundle
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION

data/lib/citier.rb

@@ -24,4 +24,7 @@ require 'citier/child_instance_methods'
 require 'citier/sql_adapters'
 
 #Require acts_as_citier hook
-require 'citier/acts_as_citier'
+require 'citier/acts_as_citier'
+
+# Methods that override ActiveRecord::Relation
+require 'citier/relation_methods'

data/lib/citier/acts_as_citier.rb

@@ -1,8 +1,10 @@
 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
+  module ActsAsCitier
+    def self.included(base) 
+      # When a class includes a module the module’s self.included method will be invoked.
+      base.send :extend, Citier::ClassMethods
+    end
   end
 end
 
-ActiveRecord::Base.send :include, Citier
+ActiveRecord::Base.send :include, Citier::ActsAsCitier

data/lib/citier/child_instance_methods.rb

@@ -1,59 +1,102 @@
-module ChildInstanceMethods
+module Citier
+  module ChildInstanceMethods
 
-  def save
+    def save(options={})
+      return false if (options[:validate] != false && !self.valid?)
+    
+      #citier_debug("Callback (#{self.inspect})")
+      citier_debug("SAVING #{self.class.to_s}")
+    
+      #AIT NOTE: Will change any protected values back to original values so any models onwards won't see changes.
+      # Run save and create/update callbacks, just like ActiveRecord does
+      self.run_callbacks(:save) do
+        self.run_callbacks(self.new_record? ? :create : :update) do
+          #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) }
+          changed_attributes_for_parent = self.changed_attributes.reject { |key,value| !self.class.superclass.column_names.include?(key) }
 
-    #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) }
+          changed_attributes_for_current = self.changed_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.superclass.to_s}: #{attributes_for_parent.inspect}")
+          citier_debug("Changed attributes for #{self.class.superclass.to_s}: #{changed_attributes_for_parent.keys.inspect}")
+          citier_debug("Attributes for #{self.class.to_s}: #{attributes_for_current.inspect}")
+          citier_debug("Changed attributes for #{self.class.to_s}: #{changed_attributes_for_current.keys.inspect}")
 
-    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 saving
+    
+          #create a new instance of the superclass, passing the inherited attributes.
+          parent = self.class.superclass.new
+      
+          parent.force_attributes(attributes_for_parent, :merge => true)
+          changed_attributes_for_parent["id"] = 0 # We need to change at least something to force a timestamps update.
+          parent.force_changed_attributes(changed_attributes_for_parent)
+      
+          parent.id = self.id if id
+          parent.type = self.type
+    
+          parent.is_new_record(new_record?)
+      
+          # If we're root (AR subclass) this will just be saved as normal through AR. If we're a child it will call this method again. 
+          # It will try and save it's parent and then save itself through the Writable constant.
+          parent_saved = parent.save
+          self.id = parent.id
 
-    parent.is_new_record(new_record?)
+          if !parent_saved
+            # Couldn't save parent class
+            citier_debug("Class (#{self.class.superclass.to_s}) could not be saved")
+            citier_debug("Errors = #{parent.errors.to_s}")
+            return false # Return false and exit run_callbacks :save and :create/:update, so the after_ callback won't run.
+          end
+    
+          #End of parent saving
+    
+          ######
+          ##
+          ## Self Saving
+          ##
 
-    parent_saved = parent.save
-    self.id = parent.id
+          # If there are attributes for the current class (unique & not inherited), save current model
+          if !attributes_for_current.empty?
+            current = self.class::Writable.new
+        
+            current.force_attributes(attributes_for_current, :merge => true)
+            current.force_changed_attributes(changed_attributes_for_current)
+        
+            current.id = self.id
+            current.is_new_record(new_record?)
+      
+            current_saved = current.save
+            
+            current.after_save_change_request if current.respond_to?('after_save_change_request') #Specific to an app I'm building
 
-    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 !current_saved
+              citier_debug("Class (#{self.class.superclass.to_s}) could not be saved")
+              citier_debug("Errors = #{current.errors.to_s}")
+              return false # Return false and exit run_callbacks :save and :create/:update, so the after callback won't run.
+            end
+          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.id = self.id
-      current.is_new_record(new_record?)
-      current_saved = current.save
-      
-      # This is no longer a new record
-      is_new_record(false)
+          # at this point, parent_saved && current_saved
+          
+          is_new_record(false) # This is no longer a new record
 
-      if(!current_saved)
-        citier_debug("Class (#{self.class.superclass.to_s}) could not be saved")
+          self.force_changed_attributes({}) # Reset changed_attributes so future changes will be tracked correctly
+          
+          # No return, because we want the after callback to run.
+        end
       end
+      return true
     end
-
-    # Update root class with this 'type'
-    if parent_saved && current_saved
-      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)
-    end
-    return parent_saved && current_saved
-  end
   
-  def save!
-    raise ActiveRecord::RecordInvalid.new(self) unless self.valid?
-    self.save
-  end
+    def save!(options={})
+      raise ActiveRecord::RecordInvalid.new(self) if (options[:validate] != false && !self.valid?)
+      self.save || raise(ActiveRecord::RecordNotSaved)
+    end
 
-  include InstanceMethods
+    include InstanceMethods
+  end
 end

data/lib/citier/class_methods.rb

@@ -1,74 +1,50 @@
-module ClassMethods
-  # any method placed here will apply to classes
-  def acts_as_citier(options = {})
+module Citier
+  module ClassMethods
+    # any method placed here will apply to classes
+    def acts_as_citier(options = {})
+      set_acts_as_citier(true)
 
-    # Option for setting the inheritance columns, default value = 'type'
-    db_type_field = (options[:db_type_field] || :type).to_s
+      # 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
+      #: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}"
+      set_inheritance_column "#{db_type_field}"
 
-    if(self.superclass!=ActiveRecord::Base)
-      # Non root-class
+      if(self.superclass!=ActiveRecord::Base)
+        # Non root-class
 
-      citier_debug("Non Root Class")
-      citier_debug("table_name -> #{table_name}")
+        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}"
+        # 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}")
+        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
+        # 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))
+        
+        after_initialize do
+          self.id = nil if self.new_record? && self.id == 0
         end
-      end
 
-      def self.find(*args) #overrides find to get all attributes
-        tuples = super
+        # Add the functions required for children only
+        send :include, Citier::ChildInstanceMethods
+      else
+      # Root class
 
-        # 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)
+        citier_debug("Root Class")
 
-        # 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
+        set_table_name "#{table_name}"
 
-      # 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
+        citier_debug("table_name -> #{self.table_name}")
 
-      # Add the functions required for root classes only
-      send :include, RootInstanceMethods
+        # Add the functions required for root classes only
+        send :include, Citier::RootInstanceMethods
+      end
     end
   end
-end  
+end

data/lib/citier/core_ext.rb

@@ -1,4 +1,12 @@
-class ActiveRecord::Base  
+class ActiveRecord::Base 
+  
+  def self.set_acts_as_citier(citier)
+    @acts_as_citier = citier
+  end
+  
+  def self.acts_as_citier?
+    @acts_as_citier || false
+  end
 
   def self.[](column_name) 
     arel_table[column_name]
@@ -7,14 +15,11 @@ class ActiveRecord::Base
   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
+      include Citier::InstanceMethods::ForcedWriters
+      
       t_name = class_reference.table_name
       t_name = t_name[5..t_name.length]
 
@@ -30,6 +35,16 @@ class ActiveRecord::Base
 end
 
 def create_citier_view(theclass)  #function for creating views for migrations 
+  # flush any column info in memory
+  # Loops through and stops once we've cleaned up to our root class.
+  # We MUST user Writable as that is the place where changes might reside!
+  reset_class = theclass::Writable 
+  until reset_class == ActiveRecord::Base
+    citier_debug("Resetting column information on #{reset_class}")
+    reset_class.reset_column_information
+    reset_class = reset_class.superclass
+  end
+
   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
@@ -37,13 +52,53 @@ def create_citier_view(theclass)  #function for creating views for migrations
   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" 
+  
+  #Use our rails_sql_views gem to create the view so we get it outputted to schema
+  create_view "#{self_read_table}", "SELECT #{parent_read_table}.id, #{columns.join(',')} FROM #{parent_read_table}, #{self_write_table} WHERE #{parent_read_table}.id = #{self_write_table}.id" do |v|
+    v.column :id
+    columns.each do |c|
+      v.column c.to_sym
+    end
+  end
+  
   citier_debug("Creating citier view -> #{sql}")
-  theclass.connection.execute 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}"
+  
+  drop_view(self_read_table.to_sym) #drop using our rails sql views gem
+  
   citier_debug("Dropping citier view -> #{sql}")
-  theclass.connection.execute sql
-end
+  #theclass.connection.execute sql
+end
+
+def update_citier_view(theclass) #function for updating views for migrations
+  
+  citier_debug("Updating citier view for #{theclass}")
+  
+  if theclass.table_exists?
+    drop_citier_view(theclass)
+    create_citier_view(theclass)
+  else
+    citier_debug("Error: #{theclass} VIEW doesn't exist.")
+  end
+  
+end
+
+def create_or_update_citier_view(theclass) #Convienience function for updating or creating views for migrations
+  
+  citier_debug("Create or Update citier view for #{theclass}")
+  
+  if theclass.table_exists?
+    update_citier_view(theclass)
+  else
+    citier_debug("VIEW DIDN'T EXIST. Now creating for #{theclass}")
+    create_citier_view(theclass)
+  end
+  
+end

data/lib/citier/instance_methods.rb

@@ -1,30 +1,37 @@
-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
+module Citier
+  module InstanceMethods    
+    def self.included(base)
+      base.send :include, ForcedWriters
+    end
+    
+    module ForcedWriters
+      def force_attributes(new_attributes, options = {})
+        new_attributes = @attributes.merge(new_attributes) if options[:merge]
+        @attributes = new_attributes
+        
+        if options[:clear_caches] != false
+          @aggregation_cache = {}
+          @association_cache = {}
+          @attributes_cache = {}
+        end
+      end
+    
+      def force_changed_attributes(new_changed_attributes, options = {})
+        new_changed_attributes = @attributes.merge(new_changed_attributes) if options[:merge]
+        @changed_attributes = new_changed_attributes
+      end
+    end
+  
+    # USAGE validates :attribute, :citier_uniqueness => true
+    # Needed because validates :attribute, :uniqueness => true  Won't work because it tries to call child_class.attribute on parents table
+    class CitierUniquenessValidator < ActiveModel::EachValidator  
+      def validate_each(object, attribute, value)
+        existing_record = object.class.where(attribute.to_sym => value).limit(1).first
+        if existing_record && existing_record.as_root != object.as_root #if prev record exist and it isn't our current obj
+              object.errors[attribute] << (options[:message] || "has already been taken.")  
+        end 
+      end  
     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

@@ -1,5 +1,44 @@
-module RootInstanceMethods
+module Citier
+  module RootInstanceMethods
 
-  include InstanceMethods
+    include InstanceMethods
+  
+    # Instantiates the instance as it's lowest root class. Used when destroying a root class to 
+    # make sure we're not leaving children behind
+    def as_child
+      #instance_class = Object.const_get(self.type)
+      return bottom_class_instance = Kernel.const_get(self.type).where(:id => self.id).first
+    end
+  
+    # Access the root class if ever you need.
+    def as_root
+       if !self.is_root?
+         root_class = self.class.base_class
 
+         #get the attributes of the class which are inherited from it's parent.
+         attributes_for_parent = self.attributes.reject{|key,value| !root_class.column_names.include?(key) }
+
+         #create a new instance of the superclass, passing the inherited attributes.
+         parent = root_class.new(attributes_for_parent)
+         parent.id = self.id
+         parent.type = self.type
+       
+         parent.is_new_record(new_record?)
+
+         parent
+       else
+          self #just return self if we are the root
+       end
+    end
+  
+    #For testing whther we are using the framework or not
+    def acts_as_citier?
+      true
+    end
+  
+    def is_root?
+      self.class.superclass==ActiveRecord::Base
+    end
+
+  end
 end

data/lib/citier/sql_adapters.rb

@@ -6,118 +6,126 @@
 #------------------------------------------------------------------------------------------------#
 
 require 'active_record'
-require 'active_record/connection_adapters/sqlite_adapter'
-require 'active_record/connection_adapters/sqlite3_adapter'
-require 'active_record/connection_adapters/postgresql_adapter'
 
 # SQLite
-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']
+begin
+  require 'active_record/connection_adapters/sqlite_adapter'
+  require 'active_record/connection_adapters/sqlite3_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
-
+  end  
+rescue Gem::LoadError
+  # not installed
 end
 
-
 # PostGreSQL
-module ActiveRecord
-  module ConnectionAdapters
-    class PostgreSQLAdapter < AbstractAdapter
-      def tables(name = nil)
-        a=tablesL(name)
-        b=viewsL(name)
-        if(b!=[])
-          a=a+b
+begin
+  require 'active_record/connection_adapters/postgresql_adapter'
+  
+  module ActiveRecord
+    module ConnectionAdapters
+      class PostgreSQLAdapter < AbstractAdapter
+        def tables(name = nil)
+          a=tablesL(name)
+          b=viewsL(name)
+          if(b!=[])
+            a=a+b
+          end
+          return a
         end
-        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)
+        def tablesL(name = nil)
 
-        query(<<-SQL, name).map { |row| row[0] }
-        SELECT viewname
-        FROM pg_views
-        WHERE schemaname = ANY (current_schemas(false))
-        SQL
-      end
+          query(<<-SQL, name).map { |row| row[0] }
+          SELECT tablename
+          FROM pg_tables
+          WHERE schemaname = ANY (current_schemas(false))
+          SQL
+        end
+        def viewsL(name = nil)
 
-      def table_exists?(name)
-        a=table_existsB?(name)
-        b=views_existsB?(name)
-        return a||b
-      end
+          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)
+          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
+        def table_existsB?(name)
+          name          = name.to_s
+          schema, table = name.split('.', 2)
 
-        if name =~ /^"/ # Handle quoted table names
-          table  = name
-          schema = nil
-        end
+          unless table # A table was provided without a schema
+            table  = schema
+            schema = nil
+          end
 
-        query(<<-SQL).first[0].to_i > 0
-        SELECT COUNT(*)
-        FROM pg_tables
-        WHERE tablename = '#{table.gsub(/(^"|"$)/,'')}'
-        #{schema ? "AND schemaname = '#{schema}'" : ''}
-        SQL
+          if name =~ /^"/ # Handle quoted table names
+            table  = name
+            schema = nil
+          end
 
-      end
-      def views_existsB?(name)
-        name          = name.to_s
-        schema, table = name.split('.', 2)
+          query(<<-SQL).first[0].to_i > 0
+          SELECT COUNT(*)
+          FROM pg_tables
+          WHERE tablename = '#{table.gsub(/(^"|"$)/,'')}'
+          #{schema ? "AND schemaname = '#{schema}'" : ''}
+          SQL
 
-        unless table # A table was provided without a schema
-          table  = schema
-          schema = nil
         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
 
-        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  
+rescue Gem::LoadError
+  # not installed
 end
 
 # MySQL

metadata

@@ -1,8 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: citier
 version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.1.12
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 13
+  version: 0.1.13
 platform: ruby
 authors: 
 - Peter Hamilton, Originally from Laurent Buffat, Pierre-Emmanuel Jouve
@@ -12,8 +16,19 @@ cert_chain: []
 
 date: 2011-04-29 00:00:00 +01:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails_sql_views
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
 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/
@@ -59,21 +74,24 @@ rdoc_options:
 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: citier
-rubygems_version: 1.6.2
+rubygems_version: 1.3.6
 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/"