torque-postgresql 0.2.16 → 1.0.0

data/lib/torque/postgresql/associations/belongs_to_many_association.rb

@@ -0,0 +1,117 @@
+require 'active_record/associations/collection_association'
+# FIXME: build, create
+module Torque
+  module PostgreSQL
+    module Associations
+      class BelongsToManyAssociation < ::ActiveRecord::Associations::CollectionAssociation
+        include ::ActiveRecord::Associations::ForeignAssociation
+
+        def handle_dependency
+          case options[:dependent]
+          when :restrict_with_exception
+            raise ::ActiveRecord::DeleteRestrictionError.new(reflection.name) unless empty?
+
+          when :restrict_with_error
+            unless empty?
+              record = owner.class.human_attribute_name(reflection.name).downcase
+              owner.errors.add(:base, :'restrict_dependent_destroy.has_many', record: record)
+              throw(:abort)
+            end
+
+          when :destroy
+            # No point in executing the counter update since we're going to destroy the parent anyway
+            load_target.each { |t| t.destroyed_by_association = reflection }
+            destroy_all
+          else
+            delete_all
+          end
+        end
+
+        def ids_reader
+          owner[reflection.active_record_primary_key]
+        end
+
+        def ids_writer(new_ids)
+          column = reflection.active_record_primary_key
+          owner.update_column(column, owner[column] = new_ids.presence)
+          @association_scope = nil
+        end
+
+        def insert_record(record, *)
+          super
+
+          attribute = (ids_reader || owner[reflection.active_record_primary_key] = [])
+          attribute.push(record[klass_fk])
+          record
+        end
+
+        def empty?
+          size.zero?
+        end
+
+        def include?(record)
+          list = owner[reflection.active_record_primary_key]
+          ids_reader && ids_reader.include?(record[klass_fk])
+        end
+
+        private
+
+          # Returns the number of records in this collection, which basically
+          # means count the number of entries in the +primary_key+
+          def count_records
+            ids_reader&.size || (@target ||= []).size
+          end
+
+          # When the idea is to nulligy the association, then just set the owner
+          # +primary_key+ as empty
+          def delete_count(method, scope, ids = nil)
+            ids ||= scope.pluck(klass_fk)
+            scope.delete_all if method == :delete_all
+            remove_stash_records(ids)
+          end
+
+          def delete_or_nullify_all_records(method)
+            delete_count(method, scope)
+          end
+
+          # Deletes the records according to the <tt>:dependent</tt> option.
+          def delete_records(records, method)
+            ids = Array.wrap(records).each_with_object(klass_fk).map(&:[])
+
+            if method == :destroy
+              records.each(&:destroy!)
+              remove_stash_records(ids)
+            else
+              scope = self.scope.where(klass_fk => records)
+              delete_count(method, scope, ids)
+            end
+          end
+
+          def concat_records(*)
+            result = super
+            ids_writer(ids_reader)
+            result
+          end
+
+          def remove_stash_records(ids)
+            return if ids_reader.nil?
+            ids_writer(ids_reader - Array.wrap(ids))
+          end
+
+          def klass_fk
+            reflection.foreign_key
+          end
+
+          def difference(a, b)
+            a - b
+          end
+
+          def intersection(a, b)
+            a & b
+          end
+      end
+
+      ::ActiveRecord::Associations.const_set(:BelongsToManyAssociation, BelongsToManyAssociation)
+    end
+  end
+end

data/lib/torque/postgresql/associations/builder.rb

@@ -0,0 +1,2 @@
+require_relative 'builder/belongs_to_many'
+require_relative 'builder/has_many'

data/lib/torque/postgresql/associations/builder/belongs_to_many.rb

@@ -0,0 +1,121 @@
+module Torque
+  module PostgreSQL
+    module Associations
+      module Builder
+        class BelongsToMany < ::ActiveRecord::Associations::Builder::CollectionAssociation
+          def self.macro
+            :belongs_to_many
+          end
+
+          def self.valid_options(options)
+            super + [:touch, :optional, :default, :dependent, :primary_key, :required]
+          end
+
+          def self.valid_dependent_options
+            [:restrict_with_error, :restrict_with_exception]
+          end
+
+          def self.define_callbacks(model, reflection)
+            super
+            add_touch_callbacks(model, reflection)   if reflection.options[:touch]
+            add_default_callbacks(model, reflection) if reflection.options[:default]
+          end
+
+          def self.define_readers(mixin, name)
+            mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+              def #{name}
+                association(:#{name}).reader
+              end
+            CODE
+          end
+
+          def self.define_writers(mixin, name)
+            mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+              def #{name}=(value)
+                association(:#{name}).writer(value)
+              end
+            CODE
+          end
+
+          def self.add_default_callbacks(model, reflection)
+            model.before_validation ->(o) do
+              o.association(reflection.name).default(&reflection.options[:default])
+            end
+          end
+
+          def self.add_touch_callbacks(model, reflection)
+            foreign_key = reflection.foreign_key
+            n           = reflection.name
+            touch       = reflection.options[:touch]
+
+            callback = ->(changes_method) do
+              ->(record) do
+                BelongsToMany.touch_record(record, record.send(changes_method), foreign_key,
+                  n, touch, belongs_to_touch_method)
+              end
+            end
+
+            unless reflection.counter_cache_column
+              model.after_create callback.call(:saved_changes), if: :saved_changes?
+              model.after_destroy callback.call(:changes_to_save)
+            end
+
+            model.after_update callback.call(:saved_changes), if: :saved_changes?
+            model.after_touch callback.call(:changes_to_save)
+          end
+
+          def self.touch_record(o, changes, foreign_key, name, touch, touch_method) # :nodoc:
+            old_foreign_ids = changes[foreign_key] && changes[foreign_key].first
+
+            if old_foreign_ids.present?
+              association = o.association(name)
+              reflection = association.reflection
+              klass = association.klass
+
+              primary_key = reflection.association_primary_key(klass)
+              old_records = klass.find_by(primary_key => old_foreign_ids)
+
+              old_records&.map do |old_record|
+                if touch != true
+                  old_record.send(touch_method, touch)
+                else
+                  old_record.send(touch_method)
+                end
+              end
+            end
+
+            o.send(name)&.map do |record|
+              if record && record.persisted?
+                if touch != true
+                  record.send(touch_method, touch)
+                else
+                  record.send(touch_method)
+                end
+              end
+            end
+          end
+
+          def self.define_validations(model, reflection)
+            if reflection.options.key?(:required)
+              reflection.options[:optional] = !reflection.options.delete(:required)
+            end
+
+            if reflection.options[:optional].nil?
+              required = model.belongs_to_many_required_by_default
+            else
+              required = !reflection.options[:optional]
+            end
+
+            super
+
+            if required
+              model.validates_presence_of reflection.name, message: :required
+            end
+          end
+        end
+
+        ::ActiveRecord::Associations::Builder.const_set(:BelongsToMany, BelongsToMany)
+      end
+    end
+  end
+end

data/lib/torque/postgresql/associations/builder/has_many.rb

@@ -0,0 +1,15 @@
+module Torque
+  module PostgreSQL
+    module Associations
+      module Builder
+        module HasMany
+          def valid_options(options)
+            super + [:array]
+          end
+        end
+
+        ::ActiveRecord::Associations::Builder::HasMany.extend(HasMany)
+      end
+    end
+  end
+end

data/lib/torque/postgresql/associations/join_dependency/join_association.rb

@@ -0,0 +1,15 @@
+module Torque
+  module PostgreSQL
+    module Associations
+      module JoinDependency
+        module JoinAssociation
+          def build_constraint(_, table, _, foreign_table, _)
+            reflection.build_join_constraint(table, foreign_table)
+          end
+        end
+
+        ::ActiveRecord::Associations::JoinDependency::JoinAssociation.prepend(JoinAssociation)
+      end
+    end
+  end
+end

data/lib/torque/postgresql/associations/preloader.rb

@@ -0,0 +1,25 @@
+require_relative 'preloader/association'
+
+unless Torque::PostgreSQL::AR521
+  module Torque
+    module PostgreSQL
+      module Associations
+        module Preloader
+          BelongsToMany = Class.new(::ActiveRecord::Associations::Preloader::HasMany)
+
+          def preloader_for(reflection, owners, *)
+            return AlreadyLoaded \
+              if owners.first.association(reflection.name).loaded?
+
+            return BelongsToMany \
+              if reflection.macro.eql?(:belongs_to_many)
+
+            super
+          end
+        end
+
+        ::ActiveRecord::Associations::Preloader.prepend(Preloader)
+      end
+    end
+  end
+end

data/lib/torque/postgresql/associations/preloader/association.rb

@@ -0,0 +1,64 @@
+module Torque
+  module PostgreSQL
+    module Associations
+      module Preloader
+        module Association
+
+          delegate :connected_through_array?, to: :@reflection
+
+          # For reflections connected through an array, make sure to properly
+          # decuple the list of ids and set them as associated with the owner
+          def run(preloader)
+            return super unless connected_through_array?
+            send("run_array_for_#{@reflection.macro}")
+          end
+
+          private
+
+            # Specific run for belongs_many association
+            def run_array_for_belongs_to_many
+              # Add reverse to has_many
+              records = load_records
+              owners.each do |owner|
+                items = records.values_at(*Array.wrap(owner[owner_key_name]))
+                associate_records_to_owner(owner, items.flatten)
+              end
+            end
+
+            # Specific run for has_many association
+            def run_array_for_has_many
+              # Add reverse to belongs_to_many
+              records = Hash.new { |h, k| h[k] = [] }
+              load_records.each do |ids, record|
+                ids.each { |id| records[id].concat(Array.wrap(record)) }
+              end
+
+              owners.each do |owner|
+                associate_records_to_owner(owner, records[owner[owner_key_name]] || [])
+              end
+            end
+
+            # Build correctly the constraint condition in order to get the
+            # associated ids
+            def records_for(ids, &block)
+              return super unless connected_through_array?
+              condition = scope.arel_attribute(association_key_name)
+              condition = reflection.build_id_constraint(condition, ids.flatten.uniq)
+              scope.where(condition).load(&block)
+            end
+
+            unless Torque::PostgreSQL::AR521
+              def associate_records_to_owner(owner, records)
+                association = owner.association(reflection.name)
+                association.loaded!
+                association.target.concat(records)
+              end
+            end
+
+        end
+
+        ::ActiveRecord::Associations::Preloader::Association.prepend(Association)
+      end
+    end
+  end
+end

data/lib/torque/postgresql/attributes.rb

@@ -4,6 +4,8 @@ require_relative 'attributes/lazy'
 require_relative 'attributes/builder'
 
 require_relative 'attributes/enum'
+require_relative 'attributes/enum_set'
+require_relative 'attributes/period'
 
 module Torque
   module PostgreSQL

data/lib/torque/postgresql/attributes/builder.rb

@@ -1 +1,2 @@
 require_relative 'builder/enum'
+require_relative 'builder/period'

data/lib/torque/postgresql/attributes/builder/enum.rb

@@ -3,11 +3,9 @@ module Torque
     module Attributes
       module Builder
         class Enum
-
           attr_accessor :klass, :attribute, :subtype, :options, :values, :enum_module
 
-          # Start a new builder of methods for composite values on
-          # ActiveRecord::Base
+          # Start a new builder of methods for enum values on ActiveRecord::Base
           def initialize(klass, attribute, subtype, options)
             @klass     = klass
             @attribute = attribute.to_s
@@ -65,7 +63,7 @@ module Torque
 
             return false
           rescue Interrupt => err
-            raise ArgumentError, <<-MSG.strip.gsub(/\n +/, ' ')
+            raise ArgumentError, <<-MSG.squish
               #{subtype.class.name} was not able to generate requested
               methods because the method #{err} already exists in
               #{klass.name}.
@@ -77,7 +75,7 @@ module Torque
             @enum_module = Module.new
 
             plural
-            text
+            stringify
             all_values
 
             klass.include enum_module
@@ -103,6 +101,8 @@ module Torque
             def plural
               attr = attribute
               enum_klass = subtype.klass
+
+              # TODO: Rewrite these as string
               enum_module.const_set('ClassMethods', Module.new)
               enum_module::ClassMethods.module_eval do
                 # def self.statuses() statuses end
@@ -126,11 +126,13 @@ module Torque
 
             # Create the method that turn the attribute value into text using
             # the model scope
-            def text
+            def stringify
               attr = attribute
+
+              # TODO: Rewrite these as string
               enum_module.module_eval do
                 # def status_text() status.text('status', self) end
-                define_method("#{attr}_text") { send(attr).text(attr, self) }
+                define_method("#{attr}_text") { send(attr)&.text(attr, self) }
               end
             end
 
@@ -139,27 +141,33 @@ module Torque
             def all_values
               attr = attribute
               vals = values_methods
+
+              enum_klass = subtype.klass
               model_klass = klass
+
+              # TODO: Rewrite these as string
               enum_module.module_eval do
                 vals.each do |val, list|
                   # scope :disabled, -> { where(status: 'disabled') }
-                  model_klass.scope list[0], -> { where(attr => val) }
+                  model_klass.scope list[0], -> do
+                    where(enum_klass.scope(arel_table[attr], val))
+                  end
 
                   # def disabled? status.disabled? end
                   define_method(list[1]) { send(attr).public_send("#{val}?") }
 
-                  # def disabled! enum_save_on_bang ? update!(status: 'disabled') : status.disabled! end
+                  # def disabled!
+                  # changed = send(attr).public_send("#{val}!")
+                  # save! if changed && enum_save_on_bang
+                  # true
                   define_method(list[2]) do
-                    if enum_save_on_bang
-                      update!(attr => val)
-                    else
-                      send(attr).public_send("#{val}!")
-                    end
+                    changed = send(attr).public_send("#{val}!")
+                    return save! if changed && enum_save_on_bang
+                    true
                   end
                 end
               end
             end
-
         end
       end
     end