torque-postgresql 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1929f5d804c0491cc94149dde4af2c7ef7e57434
-  data.tar.gz: f76c493623230594387b9b007574e4c79b778c6f
+  metadata.gz: a161d5be06adc9e93a5888b4b16b1a07b6f4a613
+  data.tar.gz: 51c1aae61c09bfa681e02daeb523551da9ef1139
 SHA512:
-  metadata.gz: 04a0d8aac7f5e29c80f2ab609b7e703524a6a04737291f68dcad0f47fc2967613771056342deb2bb4f94a731961731c94f7c8260b1041fb18e41feed47e10c7f
-  data.tar.gz: 964b8e4bed0f9a9b60ff83bd935dc41f6fd063592044d728e4aae4e7d56c6f28435e14961ce71d3b320a1b646bfbcc5181a820fac0777922d7189ad43418ae0b
+  metadata.gz: 99892a8ca40bf830e81accb0d4f15d87fbcb44697b95b4f9854a81b2e5d733c80c1a23f7312009407741ea11e7a6cb4d29acae8b03284226d618fadfbaa6a9da
+  data.tar.gz: 53e5888be0f1c89d2e30c85acc2ad350e34ad5efe6b6d899315a4cd18affe9366978d5cfd7e4ddad7843c0856ca11f7243f106d5d4ad2f538a86e2c11d5551ce

data/lib/torque/postgresql/adapter/oid/enum.rb

@@ -4,7 +4,7 @@ module Torque
       module OID
         class Enum < ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Enum
 
-          attr_reader :name, :klass
+          attr_reader :name, :klass, :set_klass, :enum_klass
 
           def self.create(row, type_map)
             name    = row['typname']
@@ -13,6 +13,7 @@ module Torque
 
             oid_klass     = Enum.new(name)
             oid_set_klass = EnumSet.new(name, oid_klass.klass)
+            oid_klass.instance_variable_set(:@set_klass, oid_set_klass)
 
             type_map.register_type(oid,     oid_klass)
             type_map.register_type(arr_oid, oid_set_klass)
@@ -21,6 +22,8 @@ module Torque
           def initialize(name)
             @name  = name
             @klass = Attributes::Enum.lookup(name)
+
+            @enum_klass = self
           end
 
           def hash
@@ -42,6 +45,12 @@ module Torque
             cast_value(value).to_sym.inspect
           end
 
+          def ==(other)
+            self.class == other.class &&
+              other.klass == klass &&
+              other.type == type
+          end
+
           private
 
             def cast_value(value)

data/lib/torque/postgresql/adapter/oid/enum_set.rb

@@ -3,12 +3,11 @@ module Torque
     module Adapter
       module OID
         class EnumSet < Enum
-
-          attr_reader :enum_klass
-
           def initialize(name, enum_klass)
             @name  = name + '[]'
             @klass = Attributes::EnumSet.lookup(name, enum_klass)
+
+            @set_klass = self
             @enum_klass = enum_klass
           end
 
@@ -16,10 +15,18 @@ module Torque
             :enum_set
           end
 
+          def deserialize(value)
+            return unless value.present?
+            value = value[1..-2].split(',') if value.is_a?(String)
+            cast_value(value)
+          end
+
           def serialize(value)
             return if value.blank?
             value = cast_value(value)
-            value.map(&:to_s) unless value.blank?
+
+            return if value.blank?
+            "{#{value.map(&:to_s).join(',')}}"
           end
 
           # Always use symbol values for schema dumper
@@ -33,7 +40,7 @@ module Torque
               return if value.blank?
               return value if value.is_a?(@klass)
               @klass.new(value)
-            rescue Attributes::EnumSet::EnumError
+            rescue Attributes::EnumSet::EnumSetError
               nil
             end
 

data/lib/torque/postgresql/adapter/oid/range.rb

@@ -25,6 +25,13 @@ module Torque
             end
           end
 
+          def map(value) # :nodoc:
+            return value unless value.respond_to?(:first)
+            from = yield(value.first)
+            to = yield(value.last)
+            cast_custom(from, to)
+          end
+
           private
 
             def cast_custom(from, to)

data/lib/torque/postgresql/adapter/quoting.rb

@@ -18,7 +18,7 @@ module Torque
         end
 
         def quote_default_expression(value, column)
-          if value.is_a?(::Enumerable)
+          if value.class <= Array
             quote(value) + '::' + column.sql_type
           else
             super

data/lib/torque/postgresql/adapter/schema_statements.rb

@@ -9,7 +9,7 @@ module Torque
         def drop_type(name, options = {})
           force = options.fetch(:force, '').upcase
           check = 'IF EXISTS' if options.fetch(:check, true)
-          execute <<-SQL
+          execute <<-SQL.squish
             DROP TYPE #{check}
             #{quote_type_name(name, options[:schema])} #{force}
           SQL
@@ -17,7 +17,7 @@ module Torque
 
         # Renames a type.
         def rename_type(type_name, new_name)
-          execute <<-SQL
+          execute <<-SQL.squish
             ALTER TYPE #{quote_type_name(type_name)}
             RENAME TO #{Quoting::Name.new(nil, new_name.to_s).quoted}
           SQL
@@ -32,7 +32,7 @@ module Torque
         #   create_enum 'status', ['foo', 'bar'], force: true
         def create_enum(name, values, options = {})
           drop_type(name, options) if options[:force]
-          execute <<-SQL
+          execute <<-SQL.squish
             CREATE TYPE #{quote_type_name(name, options[:schema])} AS ENUM
             (#{quote_enum_values(name, values, options).join(', ')})
           SQL
@@ -56,7 +56,7 @@ module Torque
           quote_enum_values(name, values, options).each do |value|
             reference = "BEFORE #{before}" unless before == false
             reference = "AFTER  #{after}"  unless after == false
-            execute <<-SQL
+            execute <<-SQL.squish
               ALTER TYPE #{quote_type_name(name, options[:schema])}
               ADD VALUE #{value} #{reference}
             SQL

data/lib/torque/postgresql/attributes.rb

@@ -1,6 +1,4 @@
-require_relative 'attributes/type_map'
 require_relative 'attributes/lazy'
-
 require_relative 'attributes/builder'
 
 require_relative 'attributes/enum'
@@ -17,24 +15,6 @@ module Torque
         class_attribute :enum_save_on_bang, instance_accessor: true
         self.enum_save_on_bang = Torque::PostgreSQL.config.enum.save_on_bang
       end
-
-      module ClassMethods
-
-        private
-
-          # If the attributes are not loaded,
-          def method_missing(method_name, *args, &block)
-            return super unless define_attribute_methods
-            self.send(method_name, *args, &block)
-          end
-
-          # Use local type map to identify attribute decorator
-          def define_attribute_method(attribute)
-            type = attribute_types[attribute]
-            super unless TypeMap.lookup(type, self, attribute)
-          end
-
-      end
     end
 
     ActiveRecord::Base.include Attributes

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

@@ -1,2 +1,30 @@
 require_relative 'builder/enum'
 require_relative 'builder/period'
+
+module Torque
+  module PostgreSQL
+    module Attributes
+      module Builder
+        def self.include_on(klass, method_name, builder_klass, &block)
+          klass.define_singleton_method(method_name) do |*args, **options|
+            return unless connection.table_exists?(table_name)
+
+            args.each do |attribute|
+              begin
+                # Generate methods on self class
+                builder = builder_klass.new(self, attribute, options)
+                builder.conflicting?
+                builder.build
+
+                # Additional settings for the builder
+                instance_exec(builder, &block) if block.present?
+              rescue Interrupt
+                # Not able to build the attribute, maybe pending migrations
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,15 +3,18 @@ module Torque
     module Attributes
       module Builder
         class Enum
+          VALID_TYPES = %i[enum enum_set].freeze
+
           attr_accessor :klass, :attribute, :subtype, :options, :values, :enum_module
 
           # Start a new builder of methods for enum values on ActiveRecord::Base
-          def initialize(klass, attribute, subtype, options)
+          def initialize(klass, attribute, options)
             @klass     = klass
             @attribute = attribute.to_s
-            @subtype   = subtype
+            @subtype   = klass.attribute_types[@attribute]
             @options   = options
 
+            raise Interrupt unless subtype.respond_to?(:klass)
             @values    = subtype.klass.values
 
             if @options[:only]
@@ -49,7 +52,7 @@ module Torque
           # Check if any of the methods that will be created get in conflict
           # with the base class methods
           def conflicting?
-            return false if options[:force] == true
+            return if options[:force] == true
             attributes = attribute.pluralize
 
             dangerous?(attributes, true)
@@ -60,11 +63,9 @@ module Torque
             values_methods.each do |attr, list|
               list.map(&method(:dangerous?))
             end
-
-            return false
           rescue Interrupt => err
             raise ArgumentError, <<-MSG.squish
-              #{subtype.class.name} was not able to generate requested
+              Enum #{subtype.name} was not able to generate requested
               methods because the method #{err} already exists in
               #{klass.name}.
             MSG

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

@@ -2,8 +2,10 @@ module Torque
   module PostgreSQL
     module Attributes
       module Builder
-        # TODO: Allow methods to have nil in order to not include that specific method
+        # TODO: Allow documenting by building the methods outside and importing
+        # only the raw string
         class Period
+          DIRECT_ACCESS_REGEX = /_?%s_?/
           SUPPORTED_TYPES = %i[daterange tsrange tstzrange].freeze
           CURRENT_GETTERS = {
             daterange: 'Date.today',
@@ -17,58 +19,77 @@ module Torque
             tstzrange: :timestamp,
           }.freeze
 
-          attr_accessor :klass, :attribute, :options, :type, :arel_attribute, :default,
-            :current_getter, :type_caster, :default_sql, :threshold, :dynamic_threshold,
-            :period_module
+          attr_accessor :klass, :attribute, :options, :type, :default, :current_getter,
+            :type_caster, :threshold, :dynamic_threshold, :klass_module, :instance_module
 
           # Start a new builder of methods for period values on
           # ActiveRecord::Base
-          def initialize(klass, attribute, _, options)
+          def initialize(klass, attribute, options)
             @klass     = klass
             @attribute = attribute.to_s
             @options   = options
             @type      = klass.attribute_types[@attribute].type
 
-            @arel_attribute = klass.arel_table[@attribute]
+            raise ArgumentError, <<-MSG.squish unless SUPPORTED_TYPES.include?(type)
+              Period cannot be generated for #{attribute} because its type
+              #{type} is not supported. Only #{SUPPORTED_TYPES.join(', ')} are supported.
+            MSG
+
             @current_getter = CURRENT_GETTERS[type]
             @type_caster    = TYPE_CASTERS[type]
 
-            @default = options[:pessimistic].blank?
-            @default_sql = ::Arel.sql(klass.connection.quote(@default))
+            @default        = options[:pessimistic].blank?
+          end
 
-            @threshold = options[:threshold].presence
+          # Check if can identify a threshold field
+          def threshold
+            @threshold ||= begin
+              option = options[:threshold]
+              return if option.eql?(false)
 
-            raise ArgumentError, <<-MSG.squish unless SUPPORTED_TYPES.include?(type)
-              Period cannot be generated for #{attribute} because its type
-              #{type} is not supported. Only #{SUPPORTED_TYPES.join(', ')} are supported.
-            MSG
+              unless option.eql?(true)
+                return option.is_a?(String) ? option.to_sym : option
+              end
+
+              attributes = klass.attribute_names
+              default_name = Torque::PostgreSQL.config.period.auto_threshold.to_s
+              raise ArgumentError, <<-MSG.squish unless attributes.include?(default_name)
+                Unable to find the #{default_name} to use as threshold for period
+                features for #{attribute} in #{klass.name} model.
+              MSG
+
+              check_type = klass.attribute_types[default_name].type
+              raise ArgumentError, <<-MSG.squish unless check_type.eql?(:interval)
+                The #{default_name} has the wrong type to be used as threshold.
+                Expected :interval got #{check_type.inspect} in #{klass.name} model.
+              MSG
+
+              default_name.to_sym
+            end
           end
 
           # Generate all the method names
           def method_names
-            @method_names ||= options.fetch(:methods, {}).symbolize_keys
-              .reverse_merge(default_method_names)
+            @method_names ||= default_method_names.merge(options.fetch(:methods, {}))
           end
 
           # Get the list of methods associated withe the class
           def klass_method_names
-            @klass_method_names ||= method_names.to_a[0..20].to_h
+            @klass_method_names ||= method_names.to_a[0..22].to_h
           end
 
           # Get the list of methods associated withe the instances
           def instance_method_names
-            @instance_method_names ||= method_names.to_a[21..27].to_h
+            @instance_method_names ||= method_names.to_a[23..29].to_h
           end
 
           # Check if any of the methods that will be created get in conflict
           # with the base class methods
           def conflicting?
-            return false if options[:force] == true
+            return if options[:force] == true
 
             klass_method_names.values.each { |name| dangerous?(name, true) }
             instance_method_names.values.each { |name| dangerous?(name) }
-
-            return false
           rescue Interrupt => err
             raise ArgumentError, <<-MSG.squish
               #{subtype.class.name} was not able to generate requested
@@ -79,99 +100,84 @@ module Torque
 
           # Create all methods needed
           def build
-            @period_module = Module.new
-
-            build_singleton_methods
-            build_instance_methods
-
-            klass.include period_module
-          end
-
-          # When the time has a threshold, then the real attribute is complex
-          def real_arel_attribute
-            return arel_attribute unless threshold.present?
-
-            left = named_function(:lower, arel_attribute) - threshold_value
-            right = named_function(:upper, arel_attribute) + threshold_value
-
-            if type.eql?(:daterange)
-              left = left.cast(:date)
-              right = right.cast(:date)
+            @klass_module = Module.new
+            @instance_module = Module.new
+
+            value_args      = ['value']
+            left_right_args = ['left', 'right = nil']
+
+            ## Klass methods
+            build_method_helper :klass, :current_on,                 value_args            # 00
+            build_method_helper :klass, :current                                           # 01
+            build_method_helper :klass, :not_current                                       # 02
+            build_method_helper :klass, :containing,                 value_args            # 03
+            build_method_helper :klass, :not_containing,             value_args            # 04
+            build_method_helper :klass, :overlapping,                left_right_args       # 05
+            build_method_helper :klass, :not_overlapping,            left_right_args       # 06
+            build_method_helper :klass, :starting_after,             value_args            # 07
+            build_method_helper :klass, :starting_before,            value_args            # 08
+            build_method_helper :klass, :finishing_after,            value_args            # 09
+            build_method_helper :klass, :finishing_before,           value_args            # 10
+
+            if threshold.present?
+              build_method_helper :klass, :real_containing,          value_args            # 11
+              build_method_helper :klass, :real_overlapping,         left_right_args       # 12
+              build_method_helper :klass, :real_starting_after,      value_args            # 13
+              build_method_helper :klass, :real_starting_before,     value_args            # 14
+              build_method_helper :klass, :real_finishing_after,     value_args            # 15
+              build_method_helper :klass, :real_finishing_before,    value_args            # 16
             end
 
-            @real_arel_attribute ||= named_function(type, left, right)
-          end
+            unless type.eql?(:daterange)
+              build_method_helper :klass, :containing_date,          value_args            # 17
+              build_method_helper :klass, :not_containing_date,      value_args            # 18
+              build_method_helper :klass, :overlapping_date,         left_right_args       # 19
+              build_method_helper :klass, :not_overlapping_date,     left_right_args       # 20
 
-          # Create an arel named function
-          def named_function(name, *args)
-            ::Arel::Nodes::NamedFunction.new(name.to_s, args)
-          end
-
-          # Create an arel version of +nullif+ function
-          def arel_nullif(*args)
-            named_function('nullif', args)
-          end
-
-          # Create an arel version of +coalesce+ function
-          def arel_coalesce(*args)
-            named_function('coalesce', args)
-          end
-
-          # Create an arel version of the type with the following values
-          def arel_convert_to_type(left, right = nil, set_type = nil)
-            named_function(set_type || type, [left, right || left])
-          end
+              if threshold.present?
+                build_method_helper :klass, :real_containing_date,   value_args            # 21
+                build_method_helper :klass, :real_overlapping_date,  left_right_args       # 22
+              end
+            end
 
-          # Convert timestamp range to date range format
-          def arel_daterange
-            named_function(
-              :daterange,
-              named_function(:lower, real_arel_attribute).cast(:date),
-              named_function(:upper, real_arel_attribute).cast(:date),
-            )
-          end
+            ## Instance methods
+            build_method_helper :instance, :current?                                       # 23
+            build_method_helper :instance, :current_on?,             value_args            # 24
+            build_method_helper :instance, :start                                          # 25
+            build_method_helper :instance, :finish                                         # 26
 
-          # Create an arel version of an empty value for the range
-          def arel_empty_value
-            arel_convert_to_type(::Arel.sql('NULL'))
-          end
+            if threshold.present?
+              build_method_helper :instance, :real                                         # 27
+              build_method_helper :instance, :real_start                                   # 28
+              build_method_helper :instance, :real_finish                                  # 29
+            end
 
-          # Create an arel not condition
-          def arel_not(value)
-            named_function(:not, value)
+            klass.extend klass_module
+            klass.include instance_module
           end
 
-          # Get the main arel condition to check the value
-          def arel_check_condition(type, value)
-            value = ::Arel.sql(klass.connection.quote(value))
+          def build_method_helper(type, key, args = [])
+            method_name = method_names[key]
+            return if method_name.nil?
 
-            checker = arel_nullif(real_arel_attribute, arel_empty_value)
-            checker = checker.public_send(type, value.cast(type_caster))
-            arel_coalesce(checker, default_sql)
-          end
+            method_content = send("#{type}_#{key}")
+            method_content = define_string_method(method_name, method_content, args)
 
-          # Check how to provide the threshold value
-          def threshold_value
-            @threshold_value ||= begin
-              case threshold
-              when Symbol, String
-                klass.arel_table[threshold]
-              when ActiveSupport::Duration
-                ::Arel.sql("'#{threshold.to_i} seconds'").cast(:interval)
-              when Numeric
-                value = threshold.to_i.to_s
-                value << type_caster.eql?(:date) ? ' days' : ' seconds'
-                ::Arel.sql("'#{value}'").cast(:interval)
-              end
-            end
+            source_module = send("#{type}_module")
+            source_module.class_eval(method_content)
           end
 
           private
 
             # Generates the default method names
             def default_method_names
-              Torque::PostgreSQL.config.period.method_names.transform_values do |value|
-                format(value, attribute)
+              list = Torque::PostgreSQL.config.period.method_names.dup
+
+              if options.fetch(:prefixed, true)
+                list.transform_values { |value| format(value, attribute) }
+              else
+                list = list.merge(Torque::PostgreSQL.config.period.direct_method_names)
+                list.transform_values { |value| value.gsub(DIRECT_ACCESS_REGEX, '') }
               end
             end
 
@@ -188,262 +194,316 @@ module Torque
               end
             end
 
-            # Build model methods
-            def build_singleton_methods
-              attr = attribute
-              builder = self
+            ## BUILDER HELPERS
+            def define_string_method(name, body, args = [])
+              headline = "def #{name}"
+              headline += "(#{args.join(', ')})"
+              [headline, body, 'end'].join("\n")
+            end
 
-              # TODO: Rewrite these as string
-              klass.scope method_names[:current_on], ->(value) do
-                where(builder.arel_check_condition(:contains, value))
-              end
+            def arel_attribute
+              @arel_attribute ||= "arel_attribute(#{attribute.inspect})"
+            end
 
-              klass.scope method_names[:current], -> do
-                public_send(builder.method_names[:current_on], eval(builder.current_getter))
-              end
+            def arel_default_sql
+              @arel_default_sql ||= arel_sql_quote(@default.inspect)
+            end
 
-              klass.scope method_names[:not_current], -> do
-                current_value = eval(builder.current_getter)
-                where.not(builder.arel_check_condition(:contains, current_value))
+            def arel_sql_quote(value)
+              "::Arel.sql(connection.quote(#{value}))"
+            end
+
+            # Check how to provide the threshold value
+            def arel_threshold_value
+              @arel_threshold_value ||= begin
+                case threshold
+                when Symbol, String
+                  "arel_attribute('#{threshold}')"
+                when ActiveSupport::Duration
+                  value = "'#{threshold.to_i} seconds'"
+                  "::Arel.sql(\"#{value}\").cast(:interval)"
+                when Numeric
+                  value = threshold.to_i.to_s
+                  value << type_caster.eql?(:date) ? ' days' : ' seconds'
+                  value = "'#{value}'"
+                  "::Arel.sql(\"#{value}\").cast(:interval)"
+                end
               end
+            end
+
+            # Start at version of the value
+            def arel_start_at
+              @arel_start_at ||= arel_named_function('lower', arel_attribute)
+            end
+
+            # Finish at version of the value
+            def arel_finish_at
+              @arel_finish_at ||= arel_named_function('upper', arel_attribute)
+            end
 
-              klass.scope method_names[:containing], ->(value) do
-                value = arel_table[value] if value.is_a?(Symbol)
-                value = ::Arel.sql(connection.quote(value)) unless value.respond_to?(:cast)
-                where(builder.arel_attribute.contains(value))
+            # Start at version of the value with threshold
+            def arel_real_start_at
+              return arel_start_at unless threshold.present?
+              @arel_real_start_at ||= begin
+                result = "(#{arel_start_at} - #{arel_threshold_value})"
+                result << '.cast(:date)' if  type.eql?(:daterange)
+                result
               end
+            end
 
-              klass.scope method_names[:not_containing], ->(value) do
-                value = arel_table[value] if value.is_a?(Symbol)
-                value = ::Arel.sql(connection.quote(value)) unless value.respond_to?(:cast)
-                where.not(builder.arel_attribute.contains(value))
+            # Finish at version of the value with threshold
+            def arel_real_finish_at
+              return arel_finish_at unless threshold.present?
+              @arel_real_finish_at ||= begin
+                result = "(#{arel_finish_at} + #{arel_threshold_value})"
+                result << '.cast(:date)' if  type.eql?(:daterange)
+                result
               end
+            end
 
-              klass.scope method_names[:overlapping], ->(value, right = nil) do
-                value = arel_table[value] if value.is_a?(Symbol)
+            # When the time has a threshold, then the real attribute is complex
+            def arel_real_attribute
+              return arel_attribute unless threshold.present?
+              @arel_real_attribute ||= arel_named_function(
+                type, arel_real_start_at, arel_real_finish_at,
+              )
+            end
 
-                if right.present?
-                  value = ::Arel.sql(connection.quote(value))
-                  right = ::Arel.sql(connection.quote(right))
-                  value = builder.arel_convert_to_type(value, right)
-                elsif !value.respond_to?(:cast)
-                  value = ::Arel.sql(connection.quote(value))
-                end
+            # Create an arel version of the type with the following values
+            def arel_convert_to_type(left, right = nil, set_type = nil)
+              arel_named_function(set_type || type, left, right || left)
+            end
 
-                where(builder.arel_attribute.overlaps(value))
-              end
+            # Create an arel named function
+            def arel_named_function(name, *args)
+              result = "::Arel::Nodes::NamedFunction.new(#{name.to_s.inspect}"
+              result << ', [' << args.join(', ') << ']' if args.present?
+              result << ')'
+            end
 
-              klass.scope method_names[:not_overlapping], ->(value, right = nil) do
-                value = arel_table[value] if value.is_a?(Symbol)
+            # Create an arel version of +nullif+ function
+            def arel_nullif(*args)
+              arel_named_function('nullif', *args)
+            end
 
-                if right.present?
-                  value = ::Arel.sql(connection.quote(value))
-                  right = ::Arel.sql(connection.quote(right))
-                  value = builder.arel_convert_to_type(value, right)
-                elsif !value.respond_to?(:cast)
-                  value = ::Arel.sql(connection.quote(value))
-                end
+            # Create an arel version of +coalesce+ function
+            def arel_coalesce(*args)
+              arel_named_function('coalesce', *args)
+            end
 
-                where.not(builder.arel_attribute.overlaps(value))
-              end
+            # Create an arel version of an empty value for the range
+            def arel_empty_value
+              arel_convert_to_type('::Arel.sql(\'NULL\')')
+            end
 
-              klass.scope method_names[:starting_after], ->(value) do
-                value = arel_table[value] if value.is_a?(Symbol)
-                value = ::Arel.sql(connection.quote(value)) \
-                  unless value.is_a?(::Arel::Attributes::Attribute)
+            # Convert timestamp range to date range format
+            def arel_daterange(real = false)
+              arel_named_function(
+                'daterange',
+                (real ? arel_real_start_at : arel_start_at) + '.cast(:date)',
+                (real ? arel_real_finish_at : arel_finish_at) + '.cast(:date)',
+                '::Arel.sql("\'[]\'")',
+              )
+            end
 
-                where(builder.named_function(:lower, builder.arel_attribute).gt(value))
-              end
+            def arel_check_condition(type)
+              checker = arel_nullif(arel_real_attribute, arel_empty_value)
+              checker << ".#{type}(value.cast(#{type_caster.inspect}))"
+              arel_coalesce(checker, arel_default_sql)
+            end
 
-              klass.scope method_names[:starting_before], ->(value) do
-                value = arel_table[value] if value.is_a?(Symbol)
-                value = ::Arel.sql(connection.quote(value)) \
-                  unless value.is_a?(::Arel::Attributes::Attribute)
+            def arel_formatting_value(condition = nil, value = 'value', cast: nil)
+              [
+                "#{value} = arel_table[#{value}] if #{value}.is_a?(Symbol)",
+                "unless #{value}.respond_to?(:cast)",
+                "  #{value} = ::Arel.sql(connection.quote(#{value}))",
+                ("  #{value} = #{value}.cast(#{cast.inspect})" if cast),
+                'end',
+                condition,
+              ].compact.join("\n")
+            end
 
-                where(builder.named_function(:lower, builder.arel_attribute).lt(value))
-              end
+            def arel_formatting_left_right(condition, set_type = nil, cast: nil)
+              [
+                arel_formatting_value(nil, 'left', cast: cast),
+                '',
+                'if right.present?',
+                '  ' + arel_formatting_value(nil, 'right', cast: cast),
+                "  value = #{arel_convert_to_type('left', 'right', set_type)}",
+                'else',
+                '  value = left',
+                'end',
+                '',
+                condition,
+              ].join("\n")
+            end
 
-              klass.scope method_names[:finishing_after], ->(value) do
-                value = arel_table[value] if value.is_a?(Symbol)
-                value = ::Arel.sql(connection.quote(value)) \
-                  unless value.is_a?(::Arel::Attributes::Attribute)
+            ## METHOD BUILDERS
+            def klass_current_on
+              arel_formatting_value("where(#{arel_check_condition(:contains)})")
+            end
 
-                where(builder.named_function(:upper, builder.arel_attribute).gt(value))
-              end
+            def klass_current
+              [
+                "value = #{arel_sql_quote(current_getter)}",
+                "where(#{arel_check_condition(:contains)})",
+              ].join("\n")
+            end
 
-              klass.scope method_names[:finishing_before], ->(value) do
-                value = arel_table[value] if value.is_a?(Symbol)
-                value = ::Arel.sql(connection.quote(value)) \
-                  unless value.is_a?(::Arel::Attributes::Attribute)
+            def klass_not_current
+              [
+                "value = #{arel_sql_quote(current_getter)}",
+                "where.not(#{arel_check_condition(:contains)})",
+              ].join("\n")
+            end
 
-                where(builder.named_function(:upper, builder.arel_attribute).lt(value))
-              end
+            def klass_containing
+              arel_formatting_value("where(#{arel_attribute}.contains(value))")
+            end
 
-              if threshold.present?
-                klass.scope method_names[:real_containing], ->(value) do
-                  value = arel_table[value] if value.is_a?(Symbol)
-                  value = ::Arel.sql(connection.quote(value)) unless value.respond_to?(:cast)
-                  where(builder.real_arel_attribute.contains(value))
-                end
+            def klass_not_containing
+              arel_formatting_value("where.not(#{arel_attribute}.contains(value))")
+            end
 
-                klass.scope method_names[:real_overlapping], ->(value, right = nil) do
-                  value = arel_table[value] if value.is_a?(Symbol)
+            def klass_overlapping
+              arel_formatting_left_right("where(#{arel_attribute}.overlaps(value))")
+            end
 
-                  if right.present?
-                    value = ::Arel.sql(connection.quote(value))
-                    right = ::Arel.sql(connection.quote(right))
-                    value = builder.arel_convert_to_type(value, right)
-                  elsif !value.respond_to?(:cast)
-                    value = ::Arel.sql(connection.quote(value))
-                  end
+            def klass_not_overlapping
+              arel_formatting_left_right("where.not(#{arel_attribute}.overlaps(value))")
+            end
 
-                  where(builder.real_arel_attribute.overlaps(value))
-                end
+            def klass_starting_after
+              arel_formatting_value("where((#{arel_start_at}).gt(value))")
+            end
 
-                klass.scope method_names[:real_starting_after], ->(value) do
-                  value = arel_table[value] if value.is_a?(Symbol)
-                  condition = builder.named_function(:lower, builder.arel_attribute)
-                  condition -= builder.threshold_value
-                  condition = condition.cast(:date) if builder.type.eql?(:daterange)
-                  where(condition.gt(value))
-                end
+            def klass_starting_before
+              arel_formatting_value("where((#{arel_start_at}).lt(value))")
+            end
 
-                klass.scope method_names[:real_starting_before], ->(value) do
-                  value = arel_table[value] if value.is_a?(Symbol)
-                  condition = builder.named_function(:lower, builder.arel_attribute)
-                  condition -= builder.threshold_value
-                  condition = condition.cast(:date) if builder.type.eql?(:daterange)
-                  where(condition.lt(value))
-                end
+            def klass_finishing_after
+              arel_formatting_value("where((#{arel_finish_at}).gt(value))")
+            end
 
-                klass.scope method_names[:real_finishing_after], ->(value) do
-                  value = arel_table[value] if value.is_a?(Symbol)
-                  condition = builder.named_function(:upper, builder.arel_attribute)
-                  condition += builder.threshold_value
-                  condition = condition.cast(:date) if builder.type.eql?(:daterange)
-                  where(condition.gt(value))
-                end
+            def klass_finishing_before
+              arel_formatting_value("where((#{arel_finish_at}).lt(value))")
+            end
 
-                klass.scope method_names[:real_finishing_before], ->(value) do
-                  value = arel_table[value] if value.is_a?(Symbol)
-                  condition = builder.named_function(:upper, builder.arel_attribute)
-                  condition += builder.threshold_value
-                  condition = condition.cast(:date) if builder.type.eql?(:daterange)
-                  where(condition.lt(value))
-                end
-              end
+            def klass_real_containing
+              arel_formatting_value("where(#{arel_real_attribute}.contains(value))")
+            end
 
-              unless type.eql?(:daterange)
-                klass.scope method_names[:containing_date], ->(value) do
-                  value = arel_table[value] if value.is_a?(Symbol)
-                  value = ::Arel.sql(connection.quote(value)) unless value.respond_to?(:cast)
-                  where(builder.arel_daterange.contains(value))
-                end
+            def klass_real_overlapping
+              arel_formatting_left_right("where(#{arel_real_attribute}.overlaps(value))")
+            end
 
-                klass.scope method_names[:not_containing_date], ->(value) do
-                  value = arel_table[value] if value.is_a?(Symbol)
-                  value = ::Arel.sql(connection.quote(value)) unless value.respond_to?(:cast)
-                  where.not(builder.arel_daterange.contains(value))
-                end
+            def klass_real_starting_after
+              arel_formatting_value("where(#{arel_real_start_at}.gt(value))")
+            end
 
-                klass.scope method_names[:overlapping_date], ->(value, right = nil) do
-                  value = arel_table[value] if value.is_a?(Symbol)
+            def klass_real_starting_before
+              arel_formatting_value("where(#{arel_real_start_at}.lt(value))")
+            end
 
-                  if right.present?
-                    value = ::Arel.sql(connection.quote(value))
-                    right = ::Arel.sql(connection.quote(right))
-                    value = builder.arel_convert_to_type(value, right, :daterange)
-                  elsif !value.respond_to?(:cast)
-                    value = ::Arel.sql(connection.quote(value))
-                  end
+            def klass_real_finishing_after
+              arel_formatting_value("where(#{arel_real_finish_at}.gt(value))")
+            end
 
-                  where(builder.arel_daterange.overlaps(value))
-                end
+            def klass_real_finishing_before
+              arel_formatting_value("where(#{arel_real_finish_at}.lt(value))")
+            end
 
-                klass.scope method_names[:not_overlapping_date], ->(value, right = nil) do
-                  value = arel_table[value] if value.is_a?(Symbol)
+            def klass_containing_date
+              arel_formatting_value("where(#{arel_daterange}.contains(value))",
+                cast: :date)
+            end
 
-                  if right.present?
-                    value = ::Arel.sql(connection.quote(value))
-                    right = ::Arel.sql(connection.quote(right))
-                    value = builder.arel_convert_to_type(value, right, :daterange)
-                  elsif !value.respond_to?(:cast)
-                    value = ::Arel.sql(connection.quote(value))
-                  end
+            def klass_not_containing_date
+              arel_formatting_value("where.not(#{arel_daterange}.contains(value))",
+                cast: :date)
+            end
 
-                  where.not(builder.arel_daterange.overlaps(value))
-                end
-              end
+            def klass_overlapping_date
+              arel_formatting_left_right("where(#{arel_daterange}.overlaps(value))",
+                :daterange, cast: :date)
+            end
+
+            def klass_not_overlapping_date
+              arel_formatting_left_right("where.not(#{arel_daterange}.overlaps(value))",
+                :daterange, cast: :date)
             end
 
-            # Build model instance methods
-            def build_instance_methods
-              attr = attribute
-              builder = self
+            def klass_real_containing_date
+              arel_formatting_value("where(#{arel_daterange(true)}.contains(value))",
+                cast: :date)
+            end
 
-              attr_threshold = threshold
-              attr_threshold = attr_threshold.to_sym if attr_threshold.is_a?(String)
-              attr_threshold = attr_threshold.seconds if attr_threshold.is_a?(Numeric)
+            def klass_real_overlapping_date
+              arel_formatting_left_right("where(#{arel_daterange(true)}.overlaps(value))",
+                :daterange, cast: :date)
+            end
 
-              # TODO: Rewrite these as string
-              period_module.module_eval do
-                define_method(builder.method_names[:current?]) do
-                  public_send(builder.method_names[:current_on?], eval(builder.current_getter))
-                end
+            def instance_current?
+              "#{method_names[:current_on?]}(#{current_getter})"
+            end
 
-                define_method(builder.method_names[:current_on?]) do |value|
-                  attr_value = builder.threshold ? builder.method_names[:real] : attr
-                  attr_value = public_send(attr_value)
+            def instance_current_on?
+              attr_value = threshold.present? ? method_names[:real] : attribute
+              default_value = default.inspect
+              [
+                "return #{default_value} if #{attr_value}.nil?",
+                "return #{default_value} if #{attr_value}.min.try(:infinite?)",
+                "return #{default_value} if #{attr_value}.max.try(:infinite?)",
+                "#{attr_value}.min < value && #{attr_value}.max > value",
+              ].join("\n")
+            end
 
-                  return builder.default if attr_value.nil? ||
-                    (attr_value.min.try(:infinite?) && attr_value.max.try(:infinite?))
+            def instance_start
+              "#{attribute}&.min"
+            end
 
-                  attr_value.min < value && attr_value.max > value
-                end
+            def instance_finish
+              "#{attribute}&.max"
+            end
 
-                define_method(builder.method_names[:start]) do
-                  public_send(attr)&.min
-                end
+            def instance_real
+              left = method_names[:real_start]
+              right = method_names[:real_finish]
 
-                define_method(builder.method_names[:finish]) do
-                  public_send(attr)&.max
-                end
+              [
+                "left = #{left}",
+                "right = #{right}",
+                'return unless left || right',
+                '((left || -::Float::INFINITY)..(right || ::Float::INFINITY))',
+              ].join("\n")
+            end
 
-                if attr_threshold.present?
-                  define_method(builder.method_names[:start]) do
-                    public_send(attr)&.min
-                  end
-
-                  define_method(builder.method_names[:finish]) do
-                    public_send(attr)&.max
-                  end
-
-                  define_method(builder.method_names[:real]) do
-                    left = public_send(builder.method_names[:real_start])
-                    right = public_send(builder.method_names[:real_finish])
-                    return unless left || right
-
-                    left ||= -::Float::INFINITY
-                    right ||= ::Float::INFINITY
-
-                    (left..right)
-                  end
-
-                  define_method(builder.method_names[:real_start]) do
-                    threshold = attr_threshold
-                    threshold = public_send(threshold) if threshold.is_a?(Symbol)
-                    result = public_send(attr)&.min.try(:-, threshold)
-                    builder.type.eql?(:daterange) ? result&.to_date : result
-                  end
-
-                  define_method(builder.method_names[:real_finish]) do
-                    threshold = attr_threshold
-                    threshold = public_send(threshold) if threshold.is_a?(Symbol)
-                    result = public_send(attr)&.max.try(:+, threshold)
-                    builder.type.eql?(:daterange) ? result&.to_date : result
-                  end
-                end
-              end
+            def instance_real_start
+              suffix = type.eql?(:daterange) ? '.to_date' : ''
+              threshold_value = threshold.is_a?(Symbol) \
+                ? threshold.to_s \
+                : threshold.to_i.to_s + '.seconds'
+
+              [
+                "return if #{method_names[:start]}.nil?",
+                "value = #{method_names[:start]}",
+                "value -= (#{threshold_value} || 0)",
+                "value#{suffix}"
+              ].join("\n")
+            end
+
+            def instance_real_finish
+              suffix = type.eql?(:daterange) ? '.to_date' : ''
+              threshold_value = threshold.is_a?(Symbol) \
+                ? threshold.to_s \
+                : threshold.to_i.to_s + '.seconds'
+
+              [
+                "return if #{method_names[:finish]}.nil?",
+                "value = #{method_names[:finish]}",
+                "value += (#{threshold_value} || 0)",
+                "value#{suffix}"
+              ].join("\n")
             end
         end
       end