dynamic-records-meritfront 3.0.26 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e61d44017d347ec7083448f67c2a3db1994f49b2a63c21d27c976c8a06c6b777
-  data.tar.gz: bbc308253515c6db53e9964701745fbbee832aee9acd7d4c1d64812b532955f3
+  metadata.gz: 187dd89025805fae04c8f188a900f6373cfd84584a720787dec852c0281a2060
+  data.tar.gz: 778e0e23ede44cc3fbb304e7216d4846745c25cb0e9fc1d87c8871375b21efcb
 SHA512:
-  metadata.gz: f5a7ae8e89825cf74e31e99e4e422087f3eacc9bb290c727c49ec272c8a40f507d932d3e64f85ee43edf8366c6b2fe6121f3303204ff759e838aaa435ea46c55
-  data.tar.gz: d70bb9d0a4ab3972ad2f940f0606a1cad2b492ad5fc8daafa892d6014800513ae4d54d2d1d3d1f47d62c3b3bcd5f89c9100173e773cb042dceef4d0b5af4fbd4
+  metadata.gz: e1071cf066822a8da8b1bf522c51c80e012b7e8c8c137aa3c7666a2965952d254bd863d4fbb9df4d77192458ff0b744a96e01e7485f2be6a94fc1faa37b1fe7f
+  data.tar.gz: eebfbac3a6a3c0202255f15bad0ced512d8c60c79f601aaada4706790a5af518c06b7413dce5ffb38e6f5e9e8318de7221ae12049ec4129f1ed23a7efb55b1d4

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dynamic-records-meritfront (3.0.26)
+    dynamic-records-meritfront (3.1.0)
       hashid-rails
 
 GEM

data/README.md

@@ -526,6 +526,39 @@ v3.0.6
 - A: We set the location of where you called the function as the default name for easy debugging. Its not an error, we just take some info from the stacktrace. It also includes the method name which can provide some insite into what the query is doing. Makes logs alot nicer to look at.
 - Q: Whats MeritFront?
 - A: I am making a social media platform
+- Q: Inspect on user records doesn't seem to work properly
+- A: inspect is overwritten by many diffrent libraries, in terms of devise for example, they override our override of active record's inspect. The best way to deal with this is to look at the source location of these methods and bring them together (user.method(:inspect).source_location). In my case with devise, i ended up with this in the user record:
+```ruby
+	def inspect
+		#this is the same as the dynamic records inspect execpt i also melded together some of the
+		#devise stuff to keep passwords etc safe
+
+		inspection = if defined?(@attributes) && @attributes
+			self.attribute_names.filter_map do |name|
+				if _has_attribute?(name)
+					if UNSAFE_ATTRIBUTES_FOR_SERIALIZATION.include? name.to_sym
+						"#{name}: [redacted]"
+					else
+						"#{name}: #{attribute_for_inspect(name)}"
+					end
+				end
+			end.join(", ")
+		else
+			"not initialized"
+		end
+
+		self.dynamic_reflections ||= []
+		dyna = self.dynamic_reflections.map{|dr|
+			[dr, self.method(dr.to_sym).call()]
+		}.to_h
+
+		if dyna.keys.any?
+			"#<#{self.class} #{inspection} | #{dyna.to_s}>"
+		else
+			"#<#{self.class} #{inspection}>"
+		end
+	end
+```
 	
 ## Contributing
 

data/lib/dynamic-records-meritfront/version.rb

@@ -1,5 +1,5 @@
 
 	module DynamicRecordsMeritfront
-	    VERSION = '3.0.26'
+	    VERSION = '3.1.0'
 	end
 	#this file gets overwritten automatically on minor updates, major ones need to be manually changed

data/lib/dynamic-records-meritfront.rb

@@ -199,18 +199,25 @@ module DynamicRecordsMeritfront
                 
         #end
 
+        # pi = atr.to_sym == :current_user_follow
+        #DevScript.ping(self.inspect) if pi
         if as_default
             if self.method(atr.to_sym).call().nil?
                 self.method("#{atr}=".to_sym).call(value)
-                # DevScript.ping("atr #{atr} def #{value}")
+                # Rails.logger.info "Y #{value.followable_type if value.respond_to? :followable_type}" if pi
             end
+            # Rails.logger.info "#{atr} ||= #{value}" if pi
         elsif push
             self.method(atr.to_sym).call().push value
+         #   Rails.logger.info #{atr} << #{value}" if pi
             # DevScript.ping("atr #{atr} push #{value}")
         else
+            #out =
             self.method("#{atr}=".to_sym).call(value)
+            # Rails.logger.info "[#{self.class.to_s} #{self.id}].#{atr} -> #{out.inspect}" if pi
             # DevScript.ping("atr #{atr} set #{value}")
         end
+        #Rails.logger.info self.inspect if pi
 
 #        raise StandardError.new('bad options') if as_default and push
 #        if as_default
@@ -291,14 +298,14 @@ module DynamicRecordsMeritfront
         end
 
         self.dynamic_reflections ||= []
-        dyna = dynamic_reflections.map{|dr|
+        dyna = self.dynamic_reflections.map{|dr|
             [dr, self.method(dr.to_sym).call()]
         }.to_h
 
-        if dyna.any?
+        if dyna.keys.any?
             "#<#{self.class} #{inspection} | #{dyna.to_s}>"
         else
-            "#<#{self.class} #{inspection} >"
+            "#<#{self.class} #{inspection}>"
         end
     end
 
@@ -661,14 +668,22 @@ module DynamicRecordsMeritfront
             #formatting options
             for insta in insta_array
                 if insta[:base_name]
-                    if insta[:as]
-                        Rails.logger.debug "#{insta[:table_name]} as #{insta[:as]} -> #{insta[:base_name]}"
-                    else
-                        Rails.logger.debug "#{insta[:table_name]} -> #{insta[:base_name]}"
-                    end
                     #in this case, 'as' is meant as to what pseudonym to dynamicly attach it as
-                    dynamic_attach(ret_hash, insta[:base_name], insta[:table_name], base_on: insta[:base_on], attach_on: insta[:attach_on],
+                    n_attached = dynamic_attach(ret_hash, insta[:base_name], insta[:table_name], base_on: insta[:base_on], attach_on: insta[:attach_on],
                         one_to_one: insta[:one_to_one], as: insta[:as])
+
+                    if Rails.logger.level <= 1
+                        tn = insta[:table_name]
+                        bn = insta[:base_name]
+                        tc = ret_hash[tn].count
+                        btc = ret_hash[bn].count
+
+                        if insta[:as]
+                            Rails.logger.debug "#{n_attached} attached from #{tn}(#{tc}) as #{insta[:as]} -> #{bn}(#{btc})"
+                        else
+                            Rails.logger.debug "#{n_attached} attached from #{tn}(#{tc}) -> #{bn}(#{btc})"
+                        end
+                    end
                 elsif insta[:as]
                     Rails.logger.debug "#{insta[:table_name]} as #{insta[:as]}"
                     #in this case, the idea is more polymorphic in nature. unless they are confused and just want to rename the table (this can be done with
@@ -789,7 +804,7 @@ module DynamicRecordsMeritfront
             base_arr = instaload_sql_output[base_name]
             
             #return if there is nothing for us to attach to.
-            return if base_arr.nil? or not base_arr.any?
+            return 0 if base_arr.nil? or not base_arr.any?
 
             #set variables for neatness and so we dont compute each time
             #	base class information
@@ -814,7 +829,7 @@ module DynamicRecordsMeritfront
 
             #make sure the attach class has something going on. We do this after the default stage
             attach_arr = instaload_sql_output[attach_name]
-            return if attach_arr.nil? or not attach_arr.any?
+            return 0 if attach_arr.nil? or not attach_arr.any?
             
             #   attach class information
             attach_class = attach_arr.first.class
@@ -833,9 +848,16 @@ module DynamicRecordsMeritfront
             end
 
             #return an id->object hash for the base table for better access
-            h = base_arr.map{|o| 
-                [base_on.call(o), o]
-            }.to_h
+            h = {}
+            duplicates_base = Set[]
+            for base_rec in base_arr
+                bo = base_on.call(base_rec)
+                if h[bo]
+                    duplicates_base << bo
+                else
+                    h[bo] = base_rec
+                end
+            end
             
             #decide on the method of getting the matching id for the attach table
             unless attach_on
@@ -880,20 +902,38 @@ module DynamicRecordsMeritfront
             #	1. match base id to the attach id (both configurable)
             #	2. cancel out if there is no match
             #	3. otherwise add to the base object.
-            attach_arr.each{|attach|
-                out = attach_on.call(attach) #you can use null to escape the vals
-                if out.nil?
+            x = 0
+
+            attach_arr.each{|attach_rec|
+                #we have it plural in case it attaches to multiple, for example a user can belong to many post-cards. Yes, this
+                #was a bug. In order to solve it you have to do some sort of 'distinct' or 'group' sql.
+                
+                attachment_keys = attach_on.call(attach_rec) #you can use null to escape the vals
+                
+                if attachment_keys.nil?
                     Rails.logger.debug "attach_on proc output (which compares to the base_on proc) is outputting nil, this could be a problem depending on your use-case."
+                elsif not attachment_keys.kind_of? Array
+                    attachment_keys = [attachment_keys]
                 end
-                if out
-                    base = h[out] #it is also escaped if no base element is found
-                    if base
-                        add_to_base.call(base, attach)
+                
+                if attachment_keys and attachment_keys.any?
+                    for ak in attachment_keys
+                        base_rec = h[ak] #it is also escaped if no base element is found
+                        if base_rec
+                            dupl = duplicates_base.include? ak
+                            if dupl
+                                Rails.logger.warn "WARNING in #{attach_name} -> #{base_name}. Duplicate base_on key being utilized (this is usually in error). Only one base record will have an attachment. For the base table, consider using GROUP BY for your id and ARRAY_AGG for the base_on column."
+                                Rails.logger.warn "base_on key: #{ak.to_s}"
+                            end
+                            
+                            x += 1 unless dupl
+                            add_to_base.call(base_rec, attach_rec)
+                        end
                     end
                 end
             }
 
-            return attach_arr
+            return x
         end
         alias swiss_attach dynamic_attach
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dynamic-records-meritfront
 version: !ruby/object:Gem::Version
-  version: 3.0.26
+  version: 3.1.0
 platform: ruby
 authors:
 - Luke Clancy
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-02-10 00:00:00.000000000 Z
+date: 2023-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashid-rails