citier4 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c50f2f638ae88ccda915b992d306c497fb103d48
-  data.tar.gz: cbcb12801ad32000c0ff2273a9ab5c22529aeb1e
+  metadata.gz: 09b3a5f7a3fa67c1f81f1c4f1712cf05dfab99df
+  data.tar.gz: f4eb2464924dd1a5996133372f5e7df8644685a8
 SHA512:
-  metadata.gz: 09276f8264eefd438650e6b70879118277256fee99af534a8bd206ee54b8ae990b6be053e3182190351cb4ee019a44097913afb8f54effd9bc9b7dd2ca3036d1
-  data.tar.gz: 30aa652b07ac0a2518cbfed45a41bac5e61c1ab36740b6918b50b79df7c5176c9aa7da6718dd483330d04b06db12433bcc7c0bedc78b4e12e05ca27fe173b0f0
+  metadata.gz: 3eac4f67749ab8a011bb6bb27d695962de49a5fa0600d8203f4093536e33f0a9dd4394f5943ba8ec1b3c797655eccf05079b621c68f58fd358a52bc42a007e5c
+  data.tar.gz: 9aae9a6a17d62d75e9f5f6b38e1b1520c9bb3616188ba4ace4d70b0e431eb543327ee16a9a5155a6f8fce0f3401fede20bb06e7e036ad733ed3ca4894d037c89

data/lib/citier4/CHANGELOG

@@ -0,0 +1,2 @@
+0.0.6
+    * create_or_replace_citier_view (update ne marche pas quand la vue est référencé par une autre table)

data/lib/citier4/acts_as_citier4.rb

@@ -38,7 +38,7 @@ module Citier4
             # 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}"
+            citier_debug("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

data/lib/citier4/child_instance_methods.rb

@@ -3,6 +3,30 @@ module Citier4
 
     citier_debug("Including Citier Child Instance")
     
+     def becomes_super
+       keys = self.class.superclass.attribute_names.dup  # car sinon, c'est la même référence
+       keys.delete(self.class.inheritance_column)
+       parent = self.class.superclass.new self.attributes.slice(*keys)
+       
+       # parent = self.class.superclass.new
+       parent.id = self.id # nul if create, a real id otherwise
+       parent.clear_changes_information 
+       # Natural Rail STI process, in new, change the "type" colomn from nil to "class.superclass.name"
+       # so we have a flaged change for this "type" colomun.
+       # And we have to clear these change
+       # Clear all changes is more simple and probably more efficient that a specific clear on the STI "type" column
+       # like the line bellow
+       # parent.clear_attribute_change(parent.class.inheritance_column)
+       parent.force_attributes(attributes_for_parent)
+       # parent.force_attributes(attributes_for_parent, :merge => true)
+       # parent = self.class.superclass.new self.changed_attributes_for_parent
+       # these doen't work, because parent.class IS NOT self.superclass, but self.class
+       # sinon, TODO, pourquoi descendre en superclass. Il faut sauter et aller a la prochaine superclass dure ...
+       parent.is_new_record(self.new_record?)
+       parent.force_changed_attributes(changed_attributes_for_parent)
+       parent
+     end
+     
     def save(options={})
       return false if (options[:validate] != false && !self.valid?)
     
@@ -31,30 +55,21 @@ module Citier4
           # Parent saving
     
           #create a new instance of the superclass, passing the inherited attributes.
-          
-          parent = self.class.superclass.new
-          parent.id = self.id # nul if create, a real id otherwise
-          parent.clear_changes_information 
-          # Natural Rail STI process, in new, change the "type" colomn from nil to "class.superclass.name"
-          # so we have a flaged change for this "type" colomun.
-          # And we have to clear these change
-          # Clear all changes is more simple and probably more efficient that a specific clear on the STI "type" column
-          # like the line bellow
-          # parent.clear_attribute_change(parent.class.inheritance_column)
-          parent.force_attributes(attributes_for_parent)
-          # parent.force_attributes(attributes_for_parent, :merge => true)
-          # parent = self.class.superclass.new self.changed_attributes_for_parent
-          # these doen't work, because parent.class IS NOT self.superclass, but self.class
-          # sinon, TODO, pourquoi descendre en superclass. Il faut sauter et aller a la prochaine superclass dure ...
-          parent.is_new_record(self.new_record?)
-          
-          parent.force_changed_attributes(changed_attributes_for_parent)
-          # parent.type = self.type
-          # parent.is_new_record(new_record?)
-      
+          # It is not good : new start callback, like after_initialise, and we doen't want to lauch such callback
+         
+          #parent1 = self.class.superclass.new 
+          #parent1.id = self.id # nul if create, a real id otherwise
+          #parent1.clear_changes_information 
+          #parent1.force_attributes(attributes_for_parent)
+          #parent1.is_new_record(self.new_record?)  
+          #parent1.force_changed_attributes(changed_attributes_for_parent)
+        
+          parent = self.becomes_super
+          # parent = parent2
           # If we're root 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.
           # For a new record, we will have an id, only when the root is saved.
+        
           parent_saved = parent.save
          #  self.id = parent.id
 
@@ -71,12 +86,12 @@ module Citier4
           # il faut quand meme sauver le current. DOTO Faire un test.
           if !attributes_for_current.empty?
            # ici, parrent est sauvé, et on a un ID
-            current = self.class::Writeable.new
-            # current.force_attributes(attributes_for_current, :merge => true)
-            current.force_attributes(attributes_for_current)
+          current = self.class::Writeable.new
+          # current.force_attributes(attributes_for_current, :merge => true)
+          current.force_attributes(attributes_for_current)
             # marche pas non plus current = self.class::Writeable.new attributes_for_current
             
-            current.force_changed_attributes(changed_attributes_for_current)
+          current.force_changed_attributes(changed_attributes_for_current)
         
             # current.id = self.id  # NON
             current.id = parent.id

data/lib/citier4/core_ext.rb

@@ -24,6 +24,7 @@ class ActiveRecord::Base
   def self.create_class_root_writable(class_reference) 
     Class.new(ActiveRecord::Base) do
       # include Citier4::InstanceMethods::ForcedWriters
+      include Citier4::RootInstanceMethods
 
       # set the name of the table associated to this class
       # this class will be associated to the writable table of the class_reference class
@@ -73,6 +74,7 @@ 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.
@@ -102,9 +104,42 @@ class ActiveRecord::Migration
     # citier_debug("Creating citier view -> #{sql}")
     #theclass.connection.execute sql
 
-
   end
 
+  def create_or_replace_citier_view(theclass) 
+     # Convienience function for updating or creating views for migrations
+     # TODO : ugly code ... (c'est le meme que create_citier, avec juste l'appel à create_or_update )
+     # 
+     # 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" 
+      #Use our rails_sql_views gem to create the view so we get it outputted to schema
+      create_or_replace_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}"
@@ -119,22 +154,13 @@ class ActiveRecord::Migration
     citier_debug("Updating citier view for #{theclass}")
     if theclass.table_exists?
       drop_citier_view(theclass)
+      # si la view est déjà utilisé, impossible de la délété.
       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

data/lib/citier4/instance_methods.rb

@@ -27,13 +27,15 @@ module Citier4
     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
+        # remplace la valeur d'un attribut par celle fournie,
+        # Ne change pas la liste des attributs.
         
         if options[:clear_caches] != false
           @aggregation_cache = {}
@@ -48,6 +50,37 @@ module Citier4
         new_changed_attributes = @attributes.merge(new_changed_attributes) if options[:merge]
         @changed_attributes = new_changed_attributes
       end
+      
+      
+      def becomes_super_old
+       #  debugger
+        keys = self.class.superclass.attribute_names.dup  # car sinon, c'est la même référence
+        keys.delete(self.class.inheritance_column)
+        became = self.class.superclass.new self.attributes.slice(*keys)
+        became.id = self.id
+        became[self.class.inheritance_column] = self[self.class.inheritance_column]
+        became.clear_changes_information 
+        #became.instance_variable_set("@changed_attributes", @changed_attributes.slice(*keys)) if defined?(@changed_attributes)
+        became.force_attributes(attributes_for_parent)
+        became.force_changed_attributes(changed_attributes_for_parent)      
+        became.instance_variable_set("@new_record", new_record?)
+        became.instance_variable_set("@destroyed", destroyed?)
+        became.instance_variable_set("@errors", errors)
+        became
+      end
+        
+      def becomes_super_old1
+        #keys = self.class.superclass.attribute_names.dup  # car sinon, c'est la même référence
+        #keys.delete(self.class.inheritance_column)
+        became = self.class.superclass.new  # self.attributes.slice(*keys)
+        became.id = self.id # nul if create, a real id otherwise
+        became.clear_changes_information 
+        became.force_attributes(attributes_for_parent)
+        became.is_new_record(self.new_record?)
+        became.force_changed_attributes(changed_attributes_for_parent) 
+        became
+      end    
+      
     end
   
     # USAGE validates :attribute, :citier_uniqueness => true

data/lib/citier4/root_class_methods.rb

@@ -29,8 +29,6 @@ module Citier4
         where(*args).take!
       rescue RangeError
         raise RecordNotFound, "Couldn't find #{@klass.name} with an out of range value"
-    end
-      
-      
-  end
+    end 
+  end  
 end

data/lib/citier4/root_instance_methods.rb

@@ -43,6 +43,9 @@ module Citier4
       # self.class.superclass==ActiveRecord::Base # eoz
       # self.class.superclass==Refinery::Core::BaseModel
     end
-
+    
+    def root_initialize
+      @attributes = self.class._default_attributes.dup
+    end
   end
 end

data/lib/citier4/version.rb

@@ -1,3 +1,3 @@
 module Citier4
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/test/changed_test.rb

@@ -11,6 +11,7 @@ end
   
 
  test "changed in find in root or child" do 
+   debugger
      book = Book.first
      book_changed = book.changed
      

data/test/child_instance_methods_test.rb

@@ -3,7 +3,7 @@ require 'test_helper'
 class ChildInstanceMethods < ActiveSupport::TestCase
 
  test "book instance is not root" do
-   assert_not Book.new.is_root?
+   assert_not Book.new(name: 'my book').is_root?
    Book.create( name: "UnLivre", author: "Inconnu")
    book = Book.find_by( name: "UnLivre")
    assert book

data/test/dummy/app/models/Foo.rb

@@ -0,0 +1,14 @@
+class Foo
+  
+    def initialize( attributes = nil, options = {}) 
+       debugger
+      # super(attributes, options)
+       puts "ici, in initalize of #{self.class.name}: #{attributes}"
+     end
+end
+
+class Bar < Foo
+  
+  # Bar.new : Appel de une ou deux fois initialize ?
+
+end

data/test/dummy/app/models/bidule.rb

@@ -1,2 +1,10 @@
 class Bidule < ActiveRecord::Base
+  
+   def initialize( attributes = nil, options = {}) 
+       debugger
+       super(attributes, options)
+       puts "ici, in initalize #{attributes}"
+     end
+     
+     
 end

data/test/dummy/app/models/product.rb

@@ -1,7 +1,162 @@
+
+#:after_initialize
+#:after_find
+#:after_touch
+#:before_validation
+#:after_validation
+#:before_save
+#:around_save
+#:after_save
+#:before_create
+#:around_create
+#:after_create
+#:before_update
+#:around_update
+#:after_update
+#:before_destroy
+#:around_destroy
+#:after_destroy
+#:after_commit
+#:after_rollback
+
+# http://edgeguides.rubyonrails.org/active_record_callbacks.html
+
+
 class Product < ActiveRecord::Base
 
    acts_as_citier4
   
    validates :name, presence: true
    
+   
+   
+    def initialize( attributes = nil, options = {}) 
+       # debugger
+       super(attributes, options)
+       if !name
+         raise "name can not be nil or blanck in initialize"
+       end 
+       puts "ici, in initalize of #{self.class.name}: #{attributes}"
+       puts "my name is : #{name}" # Just to trigger an error if name is not present 
+     end
+
+     def hello
+       puts "coucou"
+     end
+     
+     def  clone_root
+       debugger  
+       @attributes = self.class._default_attributes.dup
+     end
+     
+     def toto_initialize_copy(source)
+       # super
+       source.instance_variables.each do |var|
+         src_value  = source.instance_variable_get(var)
+         value = src_value.clone rescue src_value
+         instance_variable_set(var, value)
+       end
+     end
+      
+     
+     def rails_dup
+       debugger
+       dup
+     end
+     
+     def product_becomes( kclass)
+       debugger
+       becomes(kclass)
+     end
+     
+     def rails_becomes( klass)
+       debugger
+       became = klass.new
+       # skip_callback :after_save, :save_cookie
+       
+       # became.instance_variable_set("@attributes", @attributes)
+       # pas bon, recopie tout
+       # marche presque 
+       # became.attributes= self.attributes
+       # 
+       became.attributes = self.attributes.slice(*became.attributes.keys)
+       # became.instance_variable_set("@changed_attributes", @changed_attributes) if defined?(@changed_attributes)
+       # c'est ok, mais farie l'intersect.
+       became.instance_variable_set("@changed_attributes", @changed_attributes.slice(*became.changed_attributes.keys)) if defined?(@changed_attributes)
+       became.instance_variable_set("@new_record", new_record?)
+       became.instance_variable_set("@destroyed", destroyed?)
+       became.instance_variable_set("@errors", errors)
+       became
+     end
+     
+      def dup_becomes( klass)
+        debugger
+        # became = klass.new
+        # became = self.dup
+        became = klass.allocate
+        became.instance_variable_set("@attributes", became.class._default_attributes.dup)
+        
+
+         became.attributes = self.attributes.slice(*became.class.attribute_names)
+         # became.instance_variable_set("@changed_attributes", @changed_attributes) if defined?(@changed_attributes)
+         # c'est ok, mais farie l'intersect.
+         became.instance_variable_set("@changed_attributes", @changed_attributes.slice(*became.changed_attributes.keys)) if defined?(@changed_attributes)
+         became.instance_variable_set("@new_record", new_record?)
+         became.instance_variable_set("@destroyed", destroyed?)
+         became.instance_variable_set("@errors", errors)
+         became
+         
+      end
+
+      def becomes_klass(klass)
+        debugger
+        save_attributes = self.attributes
+        @attributes = klass._default_attributes.dup
+        self.attributes = save_attributes.slice(*klass.attribute_names)
+        @changed_attributes =  @changed_attributes.slice(*klass.attribute_names) if defined?(@changed_attributes)
+      end
+      
+       #parent1 = self.class.superclass.new self.attributes.slice(*self.class.superclass.attribute_names) # il faut enlever le type pour éviter le STI
+        #parent2 = self.class.superclass.allocate
+        #parent2.root_initialize
+        #parent2.toto_initialize_copy(self)
+        #parent_writeable_class = self.class.superclass.const_get :Writeable
+        #parent3 = parent_writeable_class.new
+        
+# get instance variable : instance_variable_get(("@" + name).intern)
+
+     def product_dup
+        debugger
+        dup = self.class.allocate
+        dup.copy_instance_variables(self)
+        dup.initialize_dup(self)
+        dup
+      end
+     
+     def private_attributes
+       @attributes
+     end
+     
+     def initialize_copy(source)
+       debugger
+       puts "Copy: #{source.inspect}"
+       super
+     end
+
+     def initialize_dup(source)
+       debugger
+       puts "Dup: #{source.inspect}"
+       super
+     end
+
+     def initialize_clone(source)
+       debugger
+       puts "Clone: #{source.inspect}"
+       super
+     end
+     
+     
+     #http://aaronlasseigne.com/2014/07/20/know-ruby-clone-and-dup/
+     
+     
 end