torque-postgresql 0.2.16 → 1.0.0

data/lib/torque/postgresql/auxiliary_statement/settings.rb

@@ -2,18 +2,29 @@ module Torque
   module PostgreSQL
     class AuxiliaryStatement
       class Settings < Collector.new(:attributes, :join, :join_type, :query, :requires,
-                                     :polymorphic)
+          :polymorphic, :through)
 
-        attr_reader :source
-        alias cte source
+        attr_reader :base, :source
+        alias_method :select, :attributes
+        alias_method :cte, :source
 
-        delegate :base, :base_name, :base_table, :table, :table_name, to: :@source
         delegate :relation_query?, to: Torque::PostgreSQL::AuxiliaryStatement
+        delegate :table, :table_name, to: :@source
+        delegate :sql, to: ::Arel
 
-        def initialize(source)
+        def initialize(base, source)
+          @base = base
           @source = source
         end
 
+        def base_name
+          @base.name
+        end
+
+        def base_table
+          @base.arel_table
+        end
+
         # Get the arel version of the table set on the query
         def query_table
           raise StandardError, 'The query is not defined yet' if query.nil?
@@ -28,11 +39,6 @@ module Torque
 
         alias column col
 
-        # Grant an easy access to arel sql literal
-        def sql(string)
-          ::Arel::Nodes::SqlLiteral.new(string)
-        end
-
         # There are two ways of setting the query:
         # - A simple relation based on a Model
         # - A Arel-based select manager
@@ -48,11 +54,13 @@ module Torque
           end
 
           valid_type = command.respond_to?(:call) || command.is_a?(String)
-          raise ArgumentError, <<-MSG.strip.gsub(/\n +/, ' ') if command.nil?
+
+          raise ArgumentError, <<-MSG.squish if command.nil?
             To use proc or string as query, you need to provide the table name
             as the first argument
           MSG
-          raise ArgumentError, <<-MSG.strip.gsub(/\n +/, ' ') unless valid_type
+
+          raise ArgumentError, <<-MSG.squish unless valid_type
             Only relation, string and proc are valid object types for query,
             #{command.inspect} given.
           MSG

data/lib/torque/postgresql/base.rb

@@ -3,6 +3,10 @@ module Torque
     module Base
       extend ActiveSupport::Concern
 
+      included do
+        mattr_accessor :belongs_to_many_required_by_default, instance_accessor: false
+      end
+
       module ClassMethods
         delegate :distinct_on, :with, :itself_only, :cast_records, to: :all
 
@@ -12,7 +16,8 @@ module Torque
           super
 
           subclass.class_attribute(:auxiliary_statements_list)
-          subclass.auxiliary_statements_list = Hash.new
+          subclass.auxiliary_statements_list = {}
+
           record_class = ActiveRecord::Relation._record_class_attribute
 
           # Define helper methods to return the class of the given records
@@ -44,6 +49,160 @@ module Torque
           end
         end
 
+        # Specifies a one-to-many association. The following methods for
+        # retrieval and query of collections of associated objects will be
+        # added:
+        #
+        # +collection+ is a placeholder for the symbol passed as the +name+
+        # argument, so <tt>belongs_to_many :tags</tt> would add among others
+        # <tt>tags.empty?</tt>.
+        #
+        # [collection]
+        #   Returns a Relation of all the associated objects.
+        #   An empty Relation is returned if none are found.
+        # [collection<<(object, ...)]
+        #   Adds one or more objects to the collection by adding their ids to
+        #   the array of ids on the parent object.
+        #   Note that this operation instantly fires update SQL without waiting
+        #   for the save or update call on the parent object, unless the parent
+        #   object is a new record.
+        #   This will also run validations and callbacks of associated
+        #   object(s).
+        # [collection.delete(object, ...)]
+        #   Removes one or more objects from the collection by removing their
+        #   ids from the list on the parent object.
+        #   Objects will be in addition destroyed if they're associated with
+        #   <tt>dependent: :destroy</tt>, and deleted if they're associated
+        #   with <tt>dependent: :delete_all</tt>.
+        # [collection.destroy(object, ...)]
+        #   Removes one or more objects from the collection by running
+        #   <tt>destroy</tt> on each record, regardless of any dependent option,
+        #   ensuring callbacks are run. They will also be removed from the list
+        #   on the parent object.
+        # [collection=objects]
+        #   Replaces the collections content by deleting and adding objects as
+        #   appropriate.
+        # [collection_singular_ids]
+        #   Returns an array of the associated objects' ids
+        # [collection_singular_ids=ids]
+        #   Replace the collection with the objects identified by the primary
+        #   keys in +ids+. This method loads the models and calls
+        #   <tt>collection=</tt>. See above.
+        # [collection.clear]
+        #   Removes every object from the collection. This destroys the
+        #   associated objects if they are associated with
+        #   <tt>dependent: :destroy</tt>, deletes them directly from the
+        #   database if <tt>dependent: :delete_all</tt>, otherwise just remove
+        #   them from the list on the parent object.
+        # [collection.empty?]
+        #   Returns +true+ if there are no associated objects.
+        # [collection.size]
+        #   Returns the number of associated objects.
+        # [collection.find(...)]
+        #   Finds an associated object according to the same rules as
+        #   ActiveRecord::FinderMethods#find.
+        # [collection.exists?(...)]
+        #   Checks whether an associated object with the given conditions exists.
+        #   Uses the same rules as ActiveRecord::FinderMethods#exists?.
+        # [collection.build(attributes = {}, ...)]
+        #   Returns one or more new objects of the collection type that have
+        #   been instantiated with +attributes+ and linked to this object by
+        #   adding its +id+ to the list after saving.
+        # [collection.create(attributes = {})]
+        #   Returns a new object of the collection type that has been
+        #   instantiated with +attributes+, linked to this object by adding its
+        #   +id+ to the list after performing the save (if it passed the
+        #   validation).
+        # [collection.create!(attributes = {})]
+        #   Does the same as <tt>collection.create</tt>, but raises
+        #   ActiveRecord::RecordInvalid if the record is invalid.
+        # [collection.reload]
+        #   Returns a Relation of all of the associated objects, forcing a
+        #   database read. An empty Relation is returned if none are found.
+        #
+        # === Example
+        #
+        # A <tt>Video</tt> class declares <tt>belongs_to_many :tags</tt>,
+        # which will add:
+        # * <tt>Video#tags</tt> (similar to <tt>Tag.where([id] && tag_ids)</tt>)
+        # * <tt>Video#tags<<</tt>
+        # * <tt>Video#tags.delete</tt>
+        # * <tt>Video#tags.destroy</tt>
+        # * <tt>Video#tags=</tt>
+        # * <tt>Video#tag_ids</tt>
+        # * <tt>Video#tag_ids=</tt>
+        # * <tt>Video#tags.clear</tt>
+        # * <tt>Video#tags.empty?</tt>
+        # * <tt>Video#tags.size</tt>
+        # * <tt>Video#tags.find</tt>
+        # * <tt>Video#tags.exists?(name: 'ACME')</tt>
+        # * <tt>Video#tags.build</tt>
+        # * <tt>Video#tags.create</tt>
+        # * <tt>Video#tags.create!</tt>
+        # * <tt>Video#tags.reload</tt>
+        # The declaration can also include an +options+ hash to specialize the
+        # behavior of the association.
+        #
+        # === Options
+        # [:class_name]
+        #   Specify the class name of the association. Use it only if that name
+        #   can't be inferred from the association name. So <tt>belongs_to_many
+        #   :tags</tt> will by default be linked to the +Tag+ class, but if the
+        #   real class name is +SpecialTag+, you'll have to specify it with this
+        #   option.
+        # [:foreign_key]
+        #   Specify the foreign key used for the association. By default this is
+        #   guessed to be the name of this class in lower-case and "_ids"
+        #   suffixed. So a Video class that makes a #belongs_to_many association
+        #   with Tag will use "tag_ids" as the default <tt>:foreign_key</tt>.
+        #
+        #   It is a good idea to set the <tt>:inverse_of</tt> option as well.
+        # [:primary_key]
+        #   Specify the name of the column to use as the primary key for the
+        #   association. By default this is +id+.
+        # [:dependent]
+        #   Controls what happens to the associated objects when their owner is
+        #   destroyed. Note that these are implemented as callbacks, and Rails
+        #   executes callbacks in order. Therefore, other similar callbacks may
+        #   affect the <tt>:dependent</tt> behavior, and the <tt>:dependent</tt>
+        #   behavior may affect other callbacks.
+        # [:touch]
+        #   If true, the associated objects will be touched (the updated_at/on
+        #   attributes set to current time) when this record is either saved or
+        #   destroyed. If you specify a symbol, that attribute will be updated
+        #   with the current time in addition to the updated_at/on attribute.
+        #   Please note that with touching no validation is performed and only
+        #   the +after_touch+, +after_commit+ and +after_rollback+ callbacks are
+        #   executed.
+        # [:optional]
+        #   When set to +true+, the association will not have its presence
+        #   validated.
+        # [:required]
+        #   When set to +true+, the association will also have its presence
+        #   validated. This will validate the association itself, not the id.
+        #   You can use +:inverse_of+ to avoid an extra query during validation.
+        #   NOTE: <tt>required</tt> is set to <tt>false</tt> by default and is
+        #   deprecated. If you want to have association presence validated,
+        #   use <tt>required: true</tt>.
+        # [:default]
+        #   Provide a callable (i.e. proc or lambda) to specify that the
+        #   association should be initialized with a particular record before
+        #   validation.
+        # [:inverse_of]
+        #   Specifies the name of the #has_many association on the associated
+        #   object that is the inverse of this #belongs_to_many association.
+        #   See ActiveRecord::Associations::ClassMethods's overview on
+        #   Bi-directional associations for more detail.
+        #
+        # Option examples:
+        #   belongs_to_many :tags, dependent: :nullify
+        #   belongs_to_many :tags, required: true, touch: true
+        #   belongs_to_many :tags, default: -> { Tag.default }
+        def belongs_to_many(name, scope = nil, **options)
+          reflection = Associations::Builder::BelongsToMany.build(self, name, scope, options)
+          ::ActiveRecord::Reflection.add_reflection(self, name, reflection)
+        end
+
         protected
 
           # Allow optional select attributes to be loaded manually when they are
@@ -134,6 +293,6 @@ module Torque
       end
     end
 
-    ActiveRecord::Base.include Base
+    ::ActiveRecord::Base.include(Base)
   end
 end

data/lib/torque/postgresql/config.rb

@@ -26,17 +26,39 @@ module Torque
       end.to_h
     end
 
+    # Configure associations features
+    config.nested(:associations) do |assoc|
+
+      # Define if +belongs_to_many+ associations are marked as required by
+      # default. False means that no validation will be performed
+      assoc.belongs_to_many_required_by_default = false
+
+    end
+
+    # Configure auxiliary statement features
+    config.nested(:auxiliary_statement) do |cte|
+
+      # Define the key that is used on auxiliary statements to send extra
+      # arguments to format string or send on a proc
+      cte.send_arguments_key = :args
+
+      # Estipulate a class name (which may contain namespace) that expose the
+      # auxiliary statement in order to perform detached CTEs
+      cte.exposed_class = 'TorqueCTE'
+
+    end
+
     # Configure ENUM features
     config.nested(:enum) do |enum|
 
-      # Indicates if the enum features on ActiveRecord::Base should be initiated
-      # automatically or not
-      enum.initializer = false
-
       # The name of the method to be used on any ActiveRecord::Base to
       # initialize model-based enum features
       enum.base_method = :enum
 
+      # The name of the method to be used on any ActiveRecord::Base to
+      # initialize model-based enum set features
+      enum.set_method = :enum_set
+
       # Indicates if bang methods like 'disabled!' should update the record on
       # database or not
       enum.save_on_bang = true
@@ -63,12 +85,28 @@ module Torque
 
     end
 
-    # Configure auxiliary statement features
-    config.nested(:auxiliary_statement) do |cte|
+    # Configure geometry data types
+    config.nested(:geometry) do |geometry|
 
-      # Define the key that is used on auxiliary statements to send extra
-      # arguments to format string or send on a proc
-      cte.send_arguments_key = :args
+      # Define the class that will be handling Point data types after decoding
+      # it. Any class provided here must respond to 'x', and 'y'
+      geometry.point_class = ActiveRecord::Point
+
+      # Define the class that will be handling Box data types after decoding it.
+      # Any class provided here must respond to 'x1', 'y1', 'x2', and 'y2'
+      geometry.box_class = nil
+
+      # Define the class that will be handling Circle data types after decoding
+      # it. Any class provided here must respond to 'x', 'y', and 'r'
+      geometry.circle_class = nil
+
+      # Define the class that will be handling Line data types after decoding
+      # it. Any class provided here must respond to 'a', 'b', and 'c'
+      geometry.line_class = nil
+
+      # Define the class that will be handling Segment data types after decoding
+      # it. Any class provided here must respond to 'x1', 'y1', 'x2', and 'y2'
+      geometry.segment_class = nil
 
     end
 
@@ -92,5 +130,49 @@ module Torque
 
     end
 
+    # Configure period features
+    config.nested(:period) do |period|
+
+      # The name of the method to be used on any ActiveRecord::Base to
+      # initialize model-based period features
+      period.base_method = :period_for
+
+      # Define the list of methods that will be created by default while setting
+      # up a new period field
+      period.method_names = {
+        current_on:            '%s_on',                       # 0
+        current:               'current_%s',                  # 1
+        not_current:           'not_current_%s',              # 2
+        containing:            '%s_containing',               # 3
+        not_containing:        '%s_not_containing',           # 4
+        overlapping:           '%s_overlapping',              # 5
+        not_overlapping:       '%s_not_overlapping',          # 6
+        starting_after:        '%s_starting_after',           # 7
+        starting_before:       '%s_starting_before',          # 8
+        finishing_after:       '%s_finishing_after',          # 9
+        finishing_before:      '%s_finishing_before',         # 10
+
+        real_containing:       '%s_real_containing',          # 11
+        real_overlapping:      '%s_real_overlapping',         # 12
+        real_starting_after:   '%s_real_starting_after',      # 13
+        real_starting_before:  '%s_real_starting_before',     # 14
+        real_finishing_after:  '%s_real_finishing_after',     # 15
+        real_finishing_before: '%s_real_finishing_before',    # 16
+
+        containing_date:       '%s_containing_date',          # 17
+        not_containing_date:   '%s_not_containing_date',      # 18
+        overlapping_date:      '%s_overlapping_date',         # 19
+        not_overlapping_date:  '%s_not_overlapping_date',     # 20
+
+        current?:              'current_%s?',                 # 21
+        current_on?:           'current_%s_on?',              # 22
+        start:                 '%s_start',                    # 23
+        finish:                '%s_finish',                   # 24
+        real:                  'real_%s',                     # 25
+        real_start:            '%s_real_start',               # 26
+        real_finish:           '%s_real_finish',              # 27
+      }
+
+    end
   end
 end

data/lib/torque/postgresql/geometry_builder.rb

@@ -0,0 +1,92 @@
+module Torque
+  module PostgreSQL
+    class GeometryBuilder < ActiveModel::Type::Value
+
+      DESTRUCTOR = /[<>{}()]/.freeze
+      NUMBER_SERIALIZER = ->(num) { num.to_s.gsub(/\.0$/, '') }
+
+      def type
+        return self.class.const_get('TYPE') if self.class.const_defined?('TYPE')
+        self.class.const_set('TYPE', self.class.name.demodulize.underscore)
+      end
+
+      def pieces
+        self.class.const_get('PIECES')
+      end
+
+      def formation
+        self.class.const_get('FORMATION')
+      end
+
+      def cast(value)
+        case value
+        when ::String
+          return if value.blank?
+          value.gsub!(DESTRUCTOR, '')
+          build_klass(*value.split(','))
+        when ::Hash
+          build_klass(*value.symbolize_keys.slice(*pieces).values)
+        when ::Array
+          build_klass(*(value.flatten))
+        else
+          value
+        end
+      end
+
+      def serialize(value)
+        parts =
+          case value
+          when config_class
+            pieces.map { |piece| value.public_send(piece) }
+          when ::Hash
+            value.symbolize_keys.slice(*pieces).values
+          when ::Array
+            value.flatten
+          end
+
+        parts = parts&.compact&.flatten
+        return if parts.blank?
+
+        raise 'Invalid format' if parts.size < pieces.size
+        format(formation, *parts.first(pieces.size).map(&number_serializer))
+      end
+
+      def deserialize(value)
+        build_klass(*value.gsub(DESTRUCTOR, '').split(',')) unless value.nil?
+      end
+
+      def type_cast_for_schema(value)
+        if config_class === value
+          pieces.map { |piece| value.public_send(piece) }
+        else
+          super
+        end
+      end
+
+      def changed_in_place?(raw_old_value, new_value)
+        raw_old_value != serialize(new_value)
+      end
+
+      protected
+
+        def number_serializer
+          self.class.const_get('NUMBER_SERIALIZER')
+        end
+
+        def config_class
+          Torque::PostgreSQL.config.geometry.public_send("#{type}_class")
+        end
+
+        def build_klass(*args)
+          return nil if args.empty?
+          check_invalid_format!(args)
+
+          config_class.new(*args.try(:first, pieces.size)&.map(&:to_f))
+        end
+
+        def check_invalid_format!(args)
+          raise 'Invalid format' if args.size < pieces.size
+        end
+    end
+  end
+end