associate_jsonb 0.0.2 → 0.0.8

data/lib/associate_jsonb/arel_extensions/visitors/postgresql.rb

@@ -0,0 +1,113 @@
+module AssociateJsonb
+  module ArelExtensions
+    module Visitors
+      module PostgreSQL
+        private
+          def collect_hash_changes(original, updated, nesting = nil)
+            keys = original.keys.map(&:to_s)
+            updated_keys = updated.keys.map(&:to_s)
+            keys |= updated_keys
+            original = original.with_indifferent_access
+            updated = updated.with_indifferent_access
+            added = []
+            deleted = []
+            finished = {}
+            keys.each do |k|
+              if updated[k].is_a?(Hash)
+                finished[k], a, d = collect_hash_changes(original[k].is_a?(Hash) ? original[k] : {}, updated[k], nesting ? "#{nesting},#{k}" : k)
+                a = [[(nesting ? "{#{nesting},#{k}}" : "{#{k}}"), {}]] if original[k].nil? && a.blank?
+                added |= a
+                deleted |= d
+              elsif updated[k].nil?
+                  deleted << (nesting ? "{#{nesting},#{k}}" : "{#{k}}") if updated_keys.include?(k)
+              elsif original[k] != updated[k]
+                finished[k] = updated[k]
+                added << [(nesting ? "{#{nesting},#{k}}" : "{#{k}}"), updated[k]]
+              end
+            end
+            [ finished, added, deleted ]
+          end
+
+          def is_hash?(type)
+            AssociateJsonb.is_hash? type
+          end
+
+          def is_update?(collector)
+            collector &&
+              Array(collector.value).any? {|v| v.is_a?(String) && (v =~ /UPDATE/) }
+          rescue
+            false
+          end
+
+          def is_insert?(collector)
+            collector &&
+              Array(collector.value).any? {|v| v.is_a?(String) && (v =~ /INSERT INTO/) }
+          rescue
+            false
+          end
+
+          def visit_BindHashChanges(t, collector)
+            changes, additions, deletions =
+              collect_hash_changes(
+                t.original_value.presence || {},
+                t.value.presence || {}
+              )
+
+            base_json = +"COALESCE(#{quote_column_name(t.name)}, '{}'::jsonb)"
+            json = base_json
+
+            deletions.each do |del|
+              json = +"(#{json} #- '#{del}')"
+            end
+
+            coalesced_paths = []
+            additions.sort.each do |add, value|
+              collector.add_bind(t.with_value_from_user(value)) do |i|
+                json = +"jsonb_nested_set(#{json},'#{add}', COALESCE($#{i}, '{}'::jsonb))"
+                ''
+              end
+            end
+
+            collector << json
+          end
+
+          def visit_Arel_Nodes_BindParam(o, collector)
+            catch(:nodes_bound) do
+              if AssociateJsonb.jsonb_set_enabled
+                catch(:not_hashable) do
+                  if is_hash?(o.value.type)
+                    if is_update?(collector)
+                      visit_BindHashChanges(o.value, collector)
+
+                      throw :nodes_bound, collector
+                    elsif is_insert?(collector)
+                      value = o.value
+
+                      value, _, _ =
+                        collect_hash_changes(
+                          {},
+                          value.value.presence || {}
+                        )
+                      throw :nodes_bound, collector.add_bind(o.value.with_cast_value(value)) { |i| "$#{i}"}
+                    else
+                      throw :not_hashable
+                    end
+                  else
+                    throw :not_hashable
+                  end
+                end
+              elsif AssociateJsonb.jsonb_delete_nil && is_hash?(o.value.type)
+                value, _, _ =
+                  collect_hash_changes(
+                    {},
+                    o.value.value.presence || {}
+                  )
+                throw :nodes_bound, collector.add_bind(o.value.with_cast_value(value)) { |i| "$#{i}" }
+              end
+              throw :nodes_bound, collector.add_bind(o.value) { |i| "$#{i}" }
+            end
+          end
+      end
+    end
+  end
+end

data/lib/associate_jsonb/arel_extensions/visitors/visitor.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ArelExtensions
+    module Visitors
+      module Visitor
+        def dispatch_cache
+          @dispatch_cache ||= Hash.new do |hash, klass|
+            hash[klass] =
+              "visit_#{(klass.name || '').
+                sub("AssociateJsonb::ArelNodes::SqlCasted", "Arel::Nodes::").
+                gsub('::', '_')}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/associate_jsonb/arel_nodes/jsonb/attribute.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ArelNodes
+    module Jsonb
+      class Attribute
+        attr_reader :relation, :name, :delegated
+
+        def initialize(relation, name, delegated)
+          @relation = relation,
+          @name = name
+          @delegated = delegated
+        end
+
+        def lower
+          relation.lower self
+        end
+
+        def type_cast_for_database(value)
+          relation.type_cast_for_database(name, value)
+        end
+
+        def able_to_type_cast?
+          relation.able_to_type_cast?
+        end
+
+        def respond_to_missing?(mthd, include_private = false)
+          delegated.respond_to?(mthd, include_private)
+        end
+
+        def method_missing(mthd, *args, **opts, &block)
+          delegated.public_send(mthd, *args, **opts, &block)
+        end
+      end
+    end
+  end
+end

data/lib/associate_jsonb/arel_nodes/sql_casted_binary.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ArelNodes
+    class SqlCastedBinary < ::Arel::Nodes::Binary
+      attr_reader :original_left
+      def initialize(left, cast_as, right)
+        @original_left = left
+        super(
+          ::Arel::Nodes::NamedFunction.new(
+            "CAST",
+            [ left.as(cast_as) ]
+          ),
+          right
+        )
+      end
+    end
+  end
+end

data/lib/associate_jsonb/arel_nodes/sql_casted_equality.rb

@@ -1,20 +1,34 @@
 # encoding: utf-8
 # frozen_string_literal: true
 
+# module AssociateJsonb
+#   module ArelNodes
+#     class SqlCastedEquality < ::Arel::Nodes::Equality
+#       attr_reader :original_left
+#       def initialize(left, cast_as, right)
+#         @original_left = left
+#         super(
+#           ::Arel::Nodes::NamedFunction.new(
+#             "CAST",
+#             [ left.as(cast_as) ]
+#           ),
+#           right
+#         )
+#       end
+#     end
+#   end
+# end
+
+
+# encoding: utf-8
+# frozen_string_literal: true
+
 module AssociateJsonb
   module ArelNodes
-    class SqlCastedEquality < ::Arel::Nodes::Equality
-      attr_reader :original_left
-      def initialize(left, cast_as, right)
-        @original_left = left
-        super(
-          ::Arel::Nodes::NamedFunction.new(
-            "CAST",
-            [ left.as(cast_as) ]
-          ),
-          right
-        )
-      end
+    class SqlCastedEquality < AssociateJsonb::ArelNodes::SqlCastedBinary
+      def operator; :== end
+      alias :operand1 :left
+      alias :operand2 :right
     end
   end
 end

data/lib/associate_jsonb/associations/alias_tracker.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/conversions"
+
+module AssociateJsonb
+  module Associations
+    module AliasTracker # :nodoc:
+      def aliased_table_for(table_name, aliased_name, type_caster, store_tracker = nil)
+        super(table_name, aliased_name, type_caster).with_store_tracker(store_tracker)
+      end
+    end
+  end
+end

data/lib/associate_jsonb/associations/association_scope.rb

@@ -4,6 +4,22 @@
 module AssociateJsonb
   module Associations
     module AssociationScope #:nodoc:
+
+      def get_chain(reflection, association, tracker)
+        name = reflection.name
+        chain = [ActiveRecord::Reflection::RuntimeReflection.new(reflection, association)]
+        reflection.chain.drop(1).each do |refl|
+          aliased_table = tracker.aliased_table_for(
+            refl.table_name,
+            refl.alias_candidate(name),
+            refl.klass.type_caster,
+            refl.klass.store_column_attribute_tracker
+          )
+          chain << ActiveRecord::Associations::AssociationScope::ReflectionProxy.new(refl, aliased_table)
+        end
+        chain
+      end
+
       # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       def last_chain_scope(scope, owner_reflection, owner)
         reflection = owner_reflection.instance_variable_get(:@reflection)
@@ -28,40 +44,21 @@ module AssociateJsonb
       # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
       def apply_jsonb_equality(scope, table, jsonb_column, store_key, foreign_key, value, foreign_klass)
-        sql_type = type = node_klass = nil
+        sql_type = type = nil
         begin
           type = foreign_klass.attribute_types[foreign_key.to_s]
           raise "type not found" unless type.present?
           sql_type = foreign_klass.columns_hash[foreign_key.to_s]
           raise "not a column" unless sql_type.present?
           sql_type = sql_type.sql_type
-          node_klass = Arel::Nodes::Jsonb::DashArrow
         rescue
           type = ActiveModel::Type::String.new
           sql_type = "text"
-          node_klass = Arel::Nodes::Jsonb::DashDoubleArrow
         end
 
-        # scope.where!(
-        #   Arel::Nodes::HashableNamedFunction.new(
-        #     "CAST",
-        #     [
-        #       node_klass.
-        #         new(table, table[jsonb_column], store_key).
-        #         as(sql_type)
-        #     ]
-        #   ).eq(
-        #     Arel::Nodes::BindParam.new(
-        #       ActiveRecord::Relation::QueryAttribute.new(
-        #         store_key, value, type
-        #       )
-        #     )
-        #   )
-        # )
-
         scope.where!(
           Arel::Nodes::SqlCastedEquality.new(
-            node_klass.new(table, table[jsonb_column], store_key),
+            Arel::Nodes::Jsonb::DashDoubleArrow.new(table, table[jsonb_column], store_key),
             sql_type,
             Arel::Nodes::BindParam.new(
               ActiveRecord::Relation::QueryAttribute.new(
@@ -70,30 +67,6 @@ module AssociateJsonb
             )
           )
         )
-
-        # scope.where!(
-        #   Arel::Nodes::Jsonb::DashDoubleArrow.
-        #     new(table, table[jsonb_column], store_key).
-        #     eq(
-        #       Arel::Nodes::BindParam.new(
-        #         ActiveRecord::Relation::QueryAttribute.new(
-        #           store_key, value, ActiveModel::Type::String.new
-        #         )
-        #       )
-        #     )
-        # )
-
-        # scope.where!(
-        #   node_klass.new(
-        #     table, table[jsonb_column], store_key
-        #   ).eq(
-        #     Arel::Nodes::BindParam.new(
-        #       ActiveRecord::Relation::QueryAttribute.new(
-        #         store_key, value, type
-        #       )
-        #     )
-        #   )
-        # )
       end
     end
   end

data/lib/associate_jsonb/associations/belongs_to_association.rb

@@ -4,14 +4,14 @@
 module AssociateJsonb
   module Associations
     module BelongsToAssociation #:nodoc:
-      def replace_keys(record)
-        return super unless reflection.options.key?(:store)
-
-        owner[reflection.foreign_key] =
-          record._read_attribute(
-            reflection.association_primary_key(record.class)
-          )
-      end
+      # def replace_keys(record)
+      #   return super unless reflection.options.key?(:store)
+      #
+      #   owner[reflection.foreign_key] =
+      #     record._read_attribute(
+      #       reflection.association_primary_key(record.class)
+      #     )
+      # end
     end
   end
 end

data/lib/associate_jsonb/associations/builder/belongs_to.rb

@@ -22,7 +22,7 @@ module AssociateJsonb
           key = (reflection.jsonb_store_key || foreign_key).to_s
           store = reflection.jsonb_store_attr
 
-          mixin.instance_eval <<-CODE, __FILE__, __LINE__ + 1
+          mixin.instance_eval <<~CODE, __FILE__, __LINE__ + 1
             if attribute_names.include?(foreign_key)
               raise AssociateJsonb::Associations::
                       ConflictingAssociation,
@@ -33,6 +33,7 @@ module AssociateJsonb
 
           opts = {}
           foreign_type = :integer
+          sql_type = "numeric"
           begin
             primary_key = reflection.active_record_primary_key.to_s
             primary_column = reflection.klass.columns.find {|col| col.name == primary_key }
@@ -40,6 +41,7 @@ module AssociateJsonb
             if primary_column
               foreign_type = primary_column.type
               sql_data = primary_column.sql_type_metadata.as_json
+              sql_type = sql_data["sql_type"]
               %i[ limit precision scale ].each do |k|
                 opts[k] = sql_data[k.to_s] if sql_data[k.to_s]
               end
@@ -49,8 +51,8 @@ module AssociateJsonb
             foreign_type = :integer
           end
 
-          mixin.instance_eval <<-CODE, __FILE__, __LINE__ + 1
-            store_column_attribute(:#{store}, :#{foreign_key}, :#{foreign_type}, key: "#{key}", **opts)
+          mixin.instance_eval <<~CODE, __FILE__, __LINE__ + 1
+            store_column_attribute(:#{store}, :#{foreign_key}, foreign_type, sql_type: sql_type, key: "#{key}", **opts)
           CODE
         end
       end

data/lib/associate_jsonb/associations/join_dependency.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/conversions"
+
+module AssociateJsonb
+  module Associations
+    module JoinDependency # :nodoc:
+      private
+        def table_aliases_for(parent, node)
+          node.reflection.chain.map { |reflection|
+            alias_tracker.aliased_table_for(
+              reflection.table_name,
+              table_alias_for(reflection, parent, reflection != node.reflection),
+              reflection.klass.type_caster,
+              reflection.klass.store_column_attribute_tracker
+            )
+          }
+        end
+    end
+  end
+end

data/lib/associate_jsonb/attribute_methods.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module AttributeMethods
+    extend ActiveSupport::Concern
+
+    included do
+      include Read
+    end
+
+    private
+      def attributes_with_info(attribute_names)
+        attribute_names.each_with_object({}) do |name, attrs|
+          attrs[name] = _fetch_attribute(name)
+        end
+      end
+  end
+end