citier4 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6d8e70049fb3abef0baa93d5e1c89e5ca2272cb4
+  data.tar.gz: fdef4f7bf35e8fa1d57b2f0b458f931375eb3bf9
+SHA512:
+  metadata.gz: 0a6fab3629ac0c6b7fd3c19badefe18c9354ebb9c3071fc5d714616bade91000289eedfcce376bbac372ccecaed473c80e91400411798ab52d02fcd9c0118ae6
+  data.tar.gz: 7e056a783abbd3827b4a5cbc5440288f61be57bf4f5595759650b43a508ce0483aceed1aead49a61bc625fe208369983b52a05b04b65ecf4a82c36969c56c434

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,3 @@
+= Citier4
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Citier4'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/citier4/acts_as_citier4.rb

@@ -0,0 +1,95 @@
+
+module Citier4
+  module ActsAsCitier4
+    
+    citier_debug("Including Citier ActAsCitier4")
+    
+    # your code will go here
+    extend ActiveSupport::Concern
+    
+    included do
+      citier_debug("ActAsCitier included")
+    end
+        
+    def self.included(base) 
+      # When a class includes a module the module’s self.included method will be invoked.
+      # base.send :extend, Citier4::ClassMethods
+    end
+    
+    module ClassMethods
+      @@first_call=true
+      
+      def acts_as_citier4(options = {})
+        # your code will go here
+        # First call, in the root class, then in a child, then in a child of child, etc ...
+            
+        set_acts_as_citier(true)
+
+        # SomesOptions are authorize only in root class, not in child
+        # but is_root? is not yet implemented
+        # but due to the inheritance cascade, the first call of "acts_as_citier" is perform in the root class
+        
+         #:table_name = option for setting the name of the current class table_name, default value = 'tableized(current class name)'
+         # option table_name is authorised in root and child
+         
+        table_name = (options[:table_name] || self.name.tableize.gsub(/\//,'_')).to_s
+        
+        if @@first_call 
+        # Unfortunatly, first_call is not a good solution when we are in developpement : acts_as_citier4 could be reload for the root class ...
+        # if ! superclass.acts_as_citier?
+            # Root class
+            # Option for setting the inheritance columns, default value = 'type'
+            # authorized only in root
+            db_type_field = (options[:db_type_field] || :type).to_s
+            puts "DODO : In Citier, we have to verify the presence of inheritance_column : #{db_type_field}"
+            self.inheritance_column = "#{db_type_field}"
+            
+             # Option for setting the super_class. Only in root
+             # maby it is not usefull any more ? TODO remove super_class
+            super_class =  (options[:super_class] || ActiveRecord::Base) # add
+
+            citier_debug("Root Class, in home directory")
+            self.table_name = "#{table_name}"
+            citier_debug("table_name -> #{self.table_name}")
+
+            # Add the functions required for root classes only
+            # include is for adding methods to an instance of a class
+            # extend is for adding class methods.
+            send :extend, Citier4::RootClassMethods
+            send :include, Citier4::RootInstanceMethods
+        else
+           citier_debug("In Child Class, not Root Class")
+            
+           # setting the inheritance columns in the child.
+           # do we have to do_it ?
+           # - in the writeable part ?
+           # - in the readable part ?
+           
+           # debugger
+           self.inheritance_column = superclass.inheritance_column
+
+          citier_debug("table_name, writable -> #{table_name}")
+          # Set up the table which contains ALL attributes we want for this class
+          self.table_name = "view_#{table_name}"      
+          citier_debug("tablename (view), readable -> #{self.table_name}")
+
+          # The the Writeable. References the write-able table for the class because
+          # save operations etc can't take place on the views
+          self.const_set("Writeable", create_class_writable(self))
+          # pour access : self.const_get :Writeable
+
+          after_initialize do
+            self.id = nil if self.new_record? && self.id == 0
+          end
+
+          # Add the functions required for children only
+          send :include, Citier4::ChildInstanceMethods
+        end
+        @@first_call = false
+      end
+
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, Citier4::ActsAsCitier4

data/lib/citier4/child_instance_methods.rb

@@ -0,0 +1,111 @@
+module Citier4
+  module ChildInstanceMethods
+
+    citier_debug("Including Citier Child Instance")
+    
+    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
+          # debugger
+          #ici
+          #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 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) }
+
+          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}")
+
+          ########
+          #
+          # 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)
+          # Ceci ne marche pas : parent = self.class.superclass.new attributes_for_parent
+          
+          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 Writeable constant.
+          parent_saved = parent.save
+          self.id = parent.id
+
+          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
+          ##
+
+          # If there are attributes for the current class (unique & not inherited), save current model
+          if !attributes_for_current.empty?
+          
+            current = self.class::Writeable.new
+            current.force_attributes(attributes_for_current, :merge => true)
+            # marche pas non plus current = self.class::Writeable.new attributes_for_current
+            
+            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 !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  
+
+          # at this point, parent_saved && current_saved
+          
+          is_new_record(false) # This is no longer a new record
+
+          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
+  
+    def save!(options={})
+      raise ActiveRecord::RecordInvalid.new(self) if (options[:validate] != false && !self.valid?)
+      self.save || raise(ActiveRecord::RecordNotSaved)
+    end
+
+    include InstanceMethods
+  end
+end

data/lib/citier4/core_ext.rb

@@ -0,0 +1,118 @@
+class ActiveRecord::Base 
+
+  citier_debug("Including Citier Core Ext")
+  
+  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]
+  end
+
+  def is_new_record(state)
+    @new_record = state
+  end
+  
+  #create the writeable class which inherits from ActiveRecord::Base
+  def self.create_class_writable(class_reference) 
+    Class.new(ActiveRecord::Base) do
+      include Citier4::InstanceMethods::ForcedWriters
+      
+      view_name = class_reference.table_name
+      # set the name of the table associated to this class
+      # this class will be associated to the writable table of the class_reference class
+      self.table_name = view_name[5..view_name.length]
+    end
+  end
+end
+
+class ActiveRecord::Migration
+  #function for creating views for migrations
+  def create_citier_view(theclass) 
+    # flush any column info in memory
+    # Loops through and stops once we've cleaned up to our root class.
+    # We MUST user Writeable as that is the place where changes might reside!
+    reset_class = theclass::Writeable 
+    until reset_class ==  ActiveRecord::Base # Refinery::Core::BaseModel # ActiveRecord::Base eoz
+      citier_debug("Resetting column information on #{reset_class}")
+      reset_class.reset_column_information
+      reset_class = reset_class.superclass
+    end
+
+    self_columns = theclass::Writeable.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::Writeable.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" 
+    debugger
+    #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
+
+
+  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
+
+  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
+
+end
+
+module ActiveRecord
+  # = Active Record Relation
+ class Relation
+
+# Causes the records to be loaded from the database if they have not
+# been loaded already. You can use this if for some reason you need
+# to explicitly load some records before actually using them. The
+# return value is the relation itself, not the records.
+#
+#   Post.where(published: true).load # => #<ActiveRecord::Relation>
+  def load
+    puts "in load de citier4"
+   exec_queries unless loaded?
+
+   self
+  end
+ end
+end

data/lib/citier4/instance_methods.rb

@@ -0,0 +1,41 @@
+module Citier4
+  module InstanceMethods    
+    def self.included(base)
+      base.send :include, ForcedWriters
+    end
+    
+    module ForcedWriters
+      def force_attributes(new_attributes, options = {})
+        # debugger
+        # TODO  new_attributes = @attributes.merge(new_attributes) if options[:merge]
+        new_attributes = self.attributes.merge(new_attributes) if options[:merge]
+        
+        # TODO @attributes = new_attributes
+        self.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
+
+  end
+end

data/lib/citier4/relation_methods.rb

@@ -0,0 +1,139 @@
+module ActiveRecord
+  class Relation
+    
+    
+    # instance.delete -> class.delete(id) -> class.where(id).delete_all
+    # donc tout finit dans delete_all
+    
+    citier_debug("Including Citier Relation")
+    
+    # http://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-delete
+    # delete_all(conditions = nil))
+    # Deletes the records matching conditions without instantiating the records first, 
+    # and hence not calling the destroy method nor invoking callbacks. 
+    # This is a single SQL DELETE statement that goes straight to the database, 
+    # much more efficient than destroy_all. 
+    # Be careful with relations though, in particular :dependent rules defined on associations 
+    # are not honored. Returns the number of rows affected.
+    
+    alias_method :relation_delete_all, :delete_all
+    
+    def delete_all(conditions = nil)
+    
+      return relation_delete_all(conditions) if !@klass.acts_as_citier?
+      return relation_delete_all(conditions) if conditions
+
+      deleted = true
+      ids = nil
+      c = @klass
+        
+      bind_values.each do |bind_value|
+        if bind_value[0].name == "id"
+          ids = bind_value[1]
+          break
+        end
+      end
+      
+      ids ||= where_values_hash["id"] || where_values_hash[:id]
+      where_hash = ids ? { :id => ids } : nil
+     
+     # debugger
+     
+      
+      # ici, si on a un dictionaire avec id 10
+      # Product.delete 10
+      # Book.delete 10
+      # Dictionary.delete 10
+      # ne vont pas faire la meme chose.
+      # Avec Product.delete 10, les Book::Writeable et Dictionary::Writeable ne sont pas déleter pour l'ID 10
+      # il faudrait pouvoir attaquer la boucle avec c = Dictionary et pas c = Product
+      
+      # ne marche que si on a que un ids et pas un tableau d'ids ...
+      if ids.class == Fixnum
+        # debugger
+        c = @klass.find(ids).class
+      end
+      
+      deleted &= c.base_class.where(where_hash).relation_delete_all
+        
+      while c.superclass !=  ActiveRecord::Base # Refinery::Core::BaseModel # eoz ActiveRecord::Base
+        if c.const_defined?(:Writeable)
+          citier_debug("Deleting back up hierarchy #{c}")
+          deleted &= c::Writeable.where(where_hash).delete_all
+        end
+        c = c.superclass
+      end
+      
+      deleted
+    end
+    
+    # TODO : remove to_a ..., will be obsolete ? and doen't work with rails 4.2 (ok for 4.1)
+    # to_a :
+    # Returns an array representation of obj. For objects of class Object and others that don’t explicitly override the method, 
+    # the return value is an array containing self. However, this latter behavior will soon be obsolete.
+    
+    alias_method :relation_to_a, :to_a  
+    def to_a
+      citier_debug("citier -> to_a")
+      return relation_to_a if !@klass.acts_as_citier?
+      records = relation_to_a
+      
+      c = @klass
+      
+      if records.all? { |record| record.class == c } 
+        return records 
+      end
+      
+      full_records = []
+      ids_wanted = {}
+      
+      # Map all the ids wanted per type
+      records.each do |record|
+        if record.class == c # We don't need to find the record again if this is already the correct one
+          full_records << record
+          next
+        end
+        
+        ids_wanted[record.class] ||= []
+        ids_wanted[record.class] << record.id
+      end
+      
+      # Find all wanted records
+      ids_wanted.each do |type_class, ids|
+        full_records.push(*type_class.find(ids))
+      end
+      
+      # Make a new array with the found records at the right places
+      records.each do |record|              
+        full_record = full_records.find { |full_record| full_record.id == record.id }
+        # debugger
+        att = full_record.instance_variable_get(:@attributes)
+        record.force_attributes(att, :merge => true, :clear_caches => false)
+        # TODO record.force_attributes(full_record.instance_variable_get(:@attributes), :merge => true, :clear_caches => false)
+      end
+      
+      return records
+    end
+    
+    # TODO
+    # apply_finder_options is depreciated in rails 4
+    # use by paginate
+    # TODO test page
+    # alias_method :relation_apply_finder_options, :apply_finder_options
+    # def apply_finder_options(options)
+    #  return relation_apply_finder_options(options) if !@klass.acts_as_citier?    
+    #   relation = self 
+    #  # With option :no_children set to true, only records of type self will be returned. 
+    #  # So Root.all(:no_children => true) won't return Child records.
+    #  no_children = options.delete(:no_children)
+    #  if no_children
+    #    relation = clone
+    #    c = @klass      
+    #    self_type = c.superclass == ActiveRecord::Base ? nil : c.name
+    #    relation = relation.where(:type => self_type)
+    #  end    
+    #  relation.relation_apply_finder_options(options)
+    # end
+    
+  end
+end

data/lib/citier4/root_class_methods.rb

@@ -0,0 +1,36 @@
+module Citier4
+  module RootClassMethods
+    
+    citier_debug("Including Citier Class Methods")
+    
+    # any method placed here will apply to classes
+    # remove the acts_as_citier definition. see file acts_as_citer
+    # def acts_as_citier(options = {})
+    # ...
+    # end
+    #def acts_as_citier?
+    #  true
+    # end
+    
+    
+    
+    # find_by and find_by! are exaclty the same defintion that ActiveRecord::FinderMethods
+    #  see finder_methods.rb
+    # but it is not these function that are call by 
+    # Post.find_by name: 'Spartacus', rating: 4
+    # but the one that are define in ActiveRecord::Core
+    # So, theses methods are here just to overwrite the one in ActiveRecord::Core
+     def find_by(*args)
+        where(*args).take
+      rescue RangeError
+        nil
+      end
+     def find_by!(*args)
+        where(*args).take!
+      rescue RangeError
+        raise RecordNotFound, "Couldn't find #{@klass.name} with an out of range value"
+    end
+      
+      
+  end
+end

data/lib/citier4/root_instance_methods.rb

@@ -0,0 +1,47 @@
+module Citier4
+  module RootInstanceMethods
+
+    citier_debug("Including Citier Root")
+      
+    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 # eoz
+      # self.class.superclass==Refinery::Core::BaseModel
+    end
+
+  end
+end

data/lib/citier4/version.rb

@@ -0,0 +1,3 @@
+module Citier4
+  VERSION = "0.0.1"
+end