dynamic-records-meritfront 3.0.26 → 3.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e61d44017d347ec7083448f67c2a3db1994f49b2a63c21d27c976c8a06c6b777
-  data.tar.gz: bbc308253515c6db53e9964701745fbbee832aee9acd7d4c1d64812b532955f3
+  metadata.gz: dd63ab9cfaf15d4472c125505260f76db354e11856a8e17aefdb2aac197fd675
+  data.tar.gz: f15916d4f9301319c8fbbcd2355cc04406dcaebe4855bfad8395629d652d182d
 SHA512:
-  metadata.gz: f5a7ae8e89825cf74e31e99e4e422087f3eacc9bb290c727c49ec272c8a40f507d932d3e64f85ee43edf8366c6b2fe6121f3303204ff759e838aaa435ea46c55
-  data.tar.gz: d70bb9d0a4ab3972ad2f940f0606a1cad2b492ad5fc8daafa892d6014800513ae4d54d2d1d3d1f47d62c3b3bcd5f89c9100173e773cb042dceef4d0b5af4fbd4
+  metadata.gz: e5af425ecff409a85dd1bdc04b3fd3bc7e7a0ecbb974e51912d66013ad57351099d6004ecd014ee08edb74830948c0ffa0cfc6e71b9b3020151c10ea3195d9ac
+  data.tar.gz: d3ac6b00f58cdd803714742eb37653a57bea2523851058a174273f15329d0da3b8577d439f7f7e878246681c60fe6e979166401a954ee400ce0b678831d490c6

data/Gemfile.lock

@@ -1,30 +1,30 @@
 PATH
   remote: .
   specs:
-    dynamic-records-meritfront (3.0.26)
+    dynamic-records-meritfront (3.1.3)
       hashid-rails
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (7.0.4.2)
-      activesupport (= 7.0.4.2)
-    activerecord (7.0.4.2)
-      activemodel (= 7.0.4.2)
-      activesupport (= 7.0.4.2)
-    activesupport (7.0.4.2)
+    activemodel (7.0.4.3)
+      activesupport (= 7.0.4.3)
+    activerecord (7.0.4.3)
+      activemodel (= 7.0.4.3)
+      activesupport (= 7.0.4.3)
+    activesupport (7.0.4.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
       tzinfo (~> 2.0)
-    concurrent-ruby (1.2.0)
+    concurrent-ruby (1.2.2)
     hashid-rails (1.4.1)
       activerecord (>= 4.0)
       hashids (~> 1.0)
     hashids (1.0.6)
     i18n (1.12.0)
       concurrent-ruby (~> 1.0)
-    minitest (5.17.0)
+    minitest (5.18.0)
     rake (12.3.3)
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)

data/README.md

@@ -5,8 +5,7 @@ Dyanmic Records Meritfront helps extend active record functionality to make it m
 2. communicate with the backend more effectively with sql queries. This becomes especially relevant when you hit the limits of Active Record Relations and the usual way of querying in rails. For instance, if you have dynamic sql queries that are hard to convert properly into ruby.
 3. add other helper methods to work with your database, such as checking if relations exist, or if a migration has been run.
 
-Note that postgres is currently a requirement for using arrays in this gem. If it becomes an issue send me a pull request or an issue or somethin.
-Also note that the gem has not been tested outside of postgres.
+Note that you will have issues using the gem outside of postgres. These issue can be fixed, and I am considering a major version update to fix them. Let me know and I will probably do it.
 
 ## Basic Examples
 ```ruby
@@ -55,7 +54,7 @@ class ApplicationRecord < ActiveRecord::Base
 end
 ```
 
-### SQL methods
+## SQL methods
 
 Methods written for easier sql usage.
 
@@ -368,6 +367,10 @@ A method used to prepare data for the instaload_sql method. It returns a hash of
 - table_name: sets the name of the temporary postgresql table. This can then be used in further instaload sql snippets.
 - relied_on: will make it so other instaload sql snippets can reference this table (it makes it use posrgresql's WITH operator)
 - dont_return: when used with relied_on makes it so that this data is not returned to rails from the database.
+- base_on: for relations, a proc describing how to attach to the base table
+- base_name: for relations, the table name for the table to attach to
+- attach_on: for relations, a proc describing how this table attaches to the the base table
+- one_to_one: for relations, a boolean that flips one-to-many/one-to-one (default false)
 
 note that the order of the instaload methods matter depending on how they reference eachother.
 <details>
@@ -393,7 +396,7 @@ taking the output of the instaload_sql method, this method creates relations bet
 - base_name: the name of the table we will be attaching to
 - attach_name: the name of the table that will be attached
 - base_on: put a proc here to override the matching key for the base table. Default is, for a user and post type, {|user| user.id}
-- attach_on: put a proc here to override the matching key for the attach table. Default is, for a user and post type, {|post| post.user_id}
+- attach_on: put a proc here to override the matching key for the attach table. Default is, for a user and post type, {|post| post.user_id}. Returning an array from this proc will make this object attach to base records that have one of those keys. This can be used with GROUP BY and ARRAY_AGG functions to stop duplicate rows while still attaching where needed. Think of attaching a user to a post where multiple posts can have the same user.
 - one_to_one: switches between a one-to-one relationship or not
 
 <details> 
@@ -421,7 +424,7 @@ printed output:
 
 </details>
 	
-### Hashed Global IDS
+## Hashed Global IDS
 
 hashed global ids look like this: "gid://meritfront/User/K9YI4K". They also have an optional tag so it can also look like "gid://meritfront/User/K9YI4K@user_image". They are based on global ids.
 
@@ -448,7 +451,9 @@ See the hashid-rails gem for more (https://github.com/jcypret/hashid-rails). Als
 
 ## Potential Issues
 
-- This gem was made with a postgresql database. This could cause a lot of issues with the sql-related methods if you do not. I dont have the bandwidth to help switch it elsewhere, but if you want to take charge of that, I would be more than happy to assist by answering questions an pointing out any areas that need transitioning.
+- This gem was made with a postgresql database. There will be some issues when using other databases. Let me know and I will help you out how I can. The main issue as far as i can tell in the transition will be with
+	1. dynamic_sql arrays. I assumed going into this that prepared statements were generated when the sql or name of the sql changed *at all*. This is not true, prepared statements are generated based on the underlying logical flow of the request. Because of this I was treating List types as postgresql array data types. Instead I should of converted them to ($1,$2,$3,$4,...etc) strings. This change would make them act similarly to how Lists of Lists are treated currently. This change would make necessary a major version change. There would also need to be an option to roll back to postgresql arrays on a case by case basis for backwards compatibility.
+	2. instaload_sql. The instaload_sql request has hardcoded sql in it that has not been tested on other databases. This may be especially problematic due to the use of the json data-type.
 - If you return a password column (for example) as pwd, this gem will accept that. That would mean that the password could me accessed as model.pwd. This is cool - until all passwords are getting logged in production servers. So be wary of accessing, storing, and logging of sensative information. Active Record has in built solutions for this type of data, as long as you dont change the column name. This gem is a sharp knife, its very versitile, but its also, you know, sharp.
 	
 ## Changelog
@@ -496,7 +501,7 @@ since things may be broken already, it seemed like a good time to do this.
   - this also tells me that uniq'ing variables to decrease the number of them was a bad idea which could cause random failures.
 - functionality improvements
   - The biggest change is that names are now optional! name_modifiers is now depreciated functionality as it serves no useful purpose. Will leave in for compatibility but take out of documentation. Used to think the name was related to prepared statements. This will lead simpler ruby code.
-  - If name is left out, the name will be set to the location in your app which called the method. For example, when dynamic_sql was called from irb, the name was: "(irb):45:in `irb_binding'". This is done using stack trace functionality. In another case the name was "app/models/report.rb:364:in `refresh_db_methods'"
+  - If name is left out, the name will be set to the location in your app which called the method. For example, when dynamic_sql was called from irb, the name was: "(irb):45:in 'irb_binding'". This is done using stack trace functionality. In another case the name was "app/models/report.rb:364:in 'refresh_db_methods'"
   - dynamic_instaload_sql is now just instaload_sql. dynamic_instaload_sql has been aliased.
   - Name is optional on instaload_sql aswell
   - MultiAttributeArrays (array's of arrays) which can be passed into dynamic_sql largely for inserts/upserts will now treat symbols as an attribute name. This leads to more consise sql without running into above error.
@@ -517,7 +522,16 @@ v3.0.6
 - I am thinking of changing how arrays are handled as that is really the only postgresql based dependency here and that will allow the library to open up to other databases. Issue is all the code I have already written in my app dependant on such things.
 
 3.0.24
-- changed how questionable_attribute_set works again, this time by using attr_accessors on the singleton class. Seems to paper over the default reflections nicely which has been a huge issue. They use this weird delegate thing which has been throwing me off. Anyway, no more evals which is nice. This fixed an issue with dynamic attach one-to-many relations.
+- changed how questionable_attribute_set works again, this time by using attr_accessors on the singleton class. Seems to paper over the default reflections nicely which has been a huge issue. They use this weird delegate thing which has been throwing me off. Anyway, no more evals which is nice. This fixed an issue with dynamic attach one-to-many relation 
+
+3.1.0
+- will try keeping breaking changes out of minor version here-on-out.
+- better debugging messages and warnings for instaload
+- returning an array in the attach_on proc will now treat each item in the array as its own attach_on key instead of all as one key. So for example you can attach one user to multiple posts, and only return one user object from the database.
+- see the dynamic_attach docs above for more on that attach_on thing.
+....
+- took out undocumented quick_safe_increment and safe_increment as they were not relevant to the gem - and fairly basic.
+
 
 ## Questions
 - Q: does the name of a sql operation have anything to do with prepared statements?
@@ -525,7 +539,40 @@ v3.0.6
 - Q: The default name of my sql statements looks like a stack trace? Whats going on?
 - 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
+- A: I am making a social media platform. See meritfront.com, Its soft launched.
+- 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.3'
 	end
 	#this file gets overwritten automatically on minor updates, major ones need to be manually changed

data/lib/dynamic-records-meritfront.rb

@@ -78,6 +78,7 @@ module DynamicRecordsMeritfront
         DB_TYPE_MAPS = {
             String => ActiveModel::Type::String,
             Symbol => ActiveModel::Type::String,
+            ActiveSupport::SafeBuffer => ActiveModel::Type::String,
             Integer => ActiveModel::Type::BigInteger,
             BigDecimal => ActiveRecord::Type::Decimal,
             TrueClass => ActiveModel::Type::Boolean,
@@ -199,18 +200,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 +299,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 +669,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 +805,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 +830,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 +849,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 +903,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 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
 
@@ -915,10 +956,11 @@ module DynamicRecordsMeritfront
                 return record
             end
         end
-
-        def quick_safe_increment(id, col, val)
-            where(id: id).update_all("#{col} = #{col} + #{val}")
-        end
+		
+		#undocumented and simple
+        #def quick_safe_increment(id, col, val)
+         #   where(id: id).update_all("#{col} = #{col} + #{val}")
+        #end
 
         
     end
@@ -955,8 +997,10 @@ module DynamicRecordsMeritfront
         self.class.headache_preload(records, associations)
     end
 
-    def safe_increment(col, val) #also used in follow, also used in comment#kill
-        self.class.where(id: self.id).update_all("#{col} = #{col} + #{val}")
-    end
+
+	#undocumented and simple
+ #   def safe_increment(col, val) #also used in follow, also used in comment#kill
+#        self.class.where(id: self.id).update_all("#{col} = #{col} + #{val}")
+  #  end
 
 end

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.3
 platform: ruby
 authors:
 - Luke Clancy
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-02-10 00:00:00.000000000 Z
+date: 2023-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashid-rails