torque-postgresql 0.2.16 → 1.0.0

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

@@ -0,0 +1,452 @@
+module Torque
+  module PostgreSQL
+    module Attributes
+      module Builder
+        # TODO: Allow methods to have nil in order to not include that specific method
+        class Period
+          SUPPORTED_TYPES = %i[daterange tsrange tstzrange].freeze
+          CURRENT_GETTERS = {
+            daterange: 'Date.today',
+            tsrange:   'Time.zone.now',
+            tstzrange: 'Time.zone.now',
+          }.freeze
+
+          TYPE_CASTERS = {
+            daterange: :date,
+            tsrange:   :timestamp,
+            tstzrange: :timestamp,
+          }.freeze
+
+          attr_accessor :klass, :attribute, :options, :type, :arel_attribute, :default,
+            :current_getter, :type_caster, :default_sql, :threshold, :dynamic_threshold,
+            :period_module
+
+          # Start a new builder of methods for period values on
+          # ActiveRecord::Base
+          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]
+            @current_getter = CURRENT_GETTERS[type]
+            @type_caster    = TYPE_CASTERS[type]
+
+            @default = options[:pessimistic].blank?
+            @default_sql = ::Arel.sql(klass.connection.quote(@default))
+
+            @threshold = options[:threshold].presence
+
+            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
+          end
+
+          # Generate all the method names
+          def method_names
+            @method_names ||= options.fetch(:methods, {}).symbolize_keys
+              .reverse_merge(default_method_names)
+          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
+          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
+          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
+
+            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
+              methods because the method #{err} already exists in
+              #{klass.name}.
+            MSG
+          end
+
+          # 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)
+            end
+
+            @real_arel_attribute ||= named_function(type, left, right)
+          end
+
+          # 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
+
+          # 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
+
+          # Create an arel version of an empty value for the range
+          def arel_empty_value
+            arel_convert_to_type(::Arel.sql('NULL'))
+          end
+
+          # Create an arel not condition
+          def arel_not(value)
+            named_function(:not, value)
+          end
+
+          # Get the main arel condition to check the value
+          def arel_check_condition(type, value)
+            value = ::Arel.sql(klass.connection.quote(value))
+
+            checker = arel_nullif(real_arel_attribute, arel_empty_value)
+            checker = checker.public_send(type, value.cast(type_caster))
+            arel_coalesce(checker, default_sql)
+          end
+
+          # 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
+          end
+
+          private
+
+            # Generates the default method names
+            def default_method_names
+              Torque::PostgreSQL.config.period.method_names.transform_values do |value|
+                format(value, attribute)
+              end
+            end
+
+            # Check if the method already exists in the reference class
+            def dangerous?(method_name, class_method = false)
+              if class_method
+                if klass.dangerous_class_method?(method_name)
+                  raise Interrupt, method_name.to_s
+                end
+              else
+                if klass.dangerous_attribute_method?(method_name)
+                  raise Interrupt, method_name.to_s
+                end
+              end
+            end
+
+            # Build model methods
+            def build_singleton_methods
+              attr = attribute
+              builder = self
+
+              # TODO: Rewrite these as string
+              klass.scope method_names[:current_on], ->(value) do
+                where(builder.arel_check_condition(:contains, value))
+              end
+
+              klass.scope method_names[:current], -> do
+                public_send(builder.method_names[:current_on], eval(builder.current_getter))
+              end
+
+              klass.scope method_names[:not_current], -> do
+                current_value = eval(builder.current_getter)
+                where.not(builder.arel_check_condition(:contains, current_value))
+              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))
+              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))
+              end
+
+              klass.scope method_names[:overlapping], ->(value, right = nil) do
+                value = arel_table[value] if value.is_a?(Symbol)
+
+                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
+
+                where(builder.arel_attribute.overlaps(value))
+              end
+
+              klass.scope method_names[:not_overlapping], ->(value, right = nil) do
+                value = arel_table[value] if value.is_a?(Symbol)
+
+                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
+
+                where.not(builder.arel_attribute.overlaps(value))
+              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)
+
+                where(builder.named_function(:lower, builder.arel_attribute).gt(value))
+              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)
+
+                where(builder.named_function(:lower, builder.arel_attribute).lt(value))
+              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)
+
+                where(builder.named_function(:upper, builder.arel_attribute).gt(value))
+              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)
+
+                where(builder.named_function(:upper, builder.arel_attribute).lt(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
+
+                klass.scope method_names[:real_overlapping], ->(value, right = nil) do
+                  value = arel_table[value] if value.is_a?(Symbol)
+
+                  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
+
+                  where(builder.real_arel_attribute.overlaps(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
+
+                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
+
+                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
+
+                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
+
+              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
+
+                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
+
+                klass.scope method_names[:overlapping_date], ->(value, right = nil) do
+                  value = arel_table[value] if value.is_a?(Symbol)
+
+                  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
+
+                  where(builder.arel_daterange.overlaps(value))
+                end
+
+                klass.scope method_names[:not_overlapping_date], ->(value, right = nil) do
+                  value = arel_table[value] if value.is_a?(Symbol)
+
+                  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
+
+                  where.not(builder.arel_daterange.overlaps(value))
+                end
+              end
+            end
+
+            # Build model instance methods
+            def build_instance_methods
+              attr = attribute
+              builder = self
+
+              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)
+
+              # 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
+
+                define_method(builder.method_names[:current_on?]) do |value|
+                  attr_value = builder.threshold ? builder.method_names[:real] : attr
+                  attr_value = public_send(attr_value)
+
+                  return builder.default if attr_value.nil? ||
+                    (attr_value.min.try(:infinite?) && attr_value.max.try(:infinite?))
+
+                  attr_value.min < value && attr_value.max > value
+                end
+
+                define_method(builder.method_names[:start]) do
+                  public_send(attr)&.min
+                end
+
+                define_method(builder.method_names[:finish]) do
+                  public_send(attr)&.max
+                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
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -11,7 +11,7 @@ module Torque
         class << self
           include Enumerable
 
-          delegate :each, :sample, to: :members
+          delegate :each, :sample, :size, :length, to: :members
 
           # Find or create the class that will handle the value
           def lookup(name)
@@ -72,8 +72,7 @@ module Torque
           # see https://github.com/rails/rails/blob/v5.0.0/activerecord/lib/active_record/fixtures.rb#L656
           # see https://github.com/rails/rails/blob/v5.0.0/activerecord/lib/active_record/validations/uniqueness.rb#L101
           def fetch(value, *)
-            return nil unless values.include?(value)
-            send(value)
+            new(value.to_s) if values.include?(value)
           end
           alias [] fetch
 
@@ -89,11 +88,16 @@ module Torque
             self.values.include?(value.to_s)
           end
 
+          # Build an active record scope for a given atribute agains a value
+          def scope(attribute, value)
+            attribute.eq(value)
+          end
+
           private
 
             # Allows checking value existance
             def respond_to_missing?(method_name, include_private = false)
-              valid?(method_name)
+              valid?(method_name) || super
             end
 
             # Allow fast creation of values
@@ -165,7 +169,7 @@ module Torque
 
         # Change the inspection to show the enum name
         def inspect
-          nil? ? 'nil' : "#<#{self.class.name} #{super}>"
+          nil? ? 'nil' : ":#{to_s}"
         end
 
         private
@@ -199,9 +203,9 @@ module Torque
             name = method_name.to_s
 
             if name.chomp!('?')
-              self == name.tr('_', '-') || self == name
+              self == name
             elsif name.chomp!('!')
-              replace(name)
+              replace(name) unless self == name
             else
               super
             end
@@ -220,7 +224,6 @@ module Torque
           def raise_comparison(other)
             raise EnumError, "Comparison of #{self.class.name} with #{self.inspect} failed"
           end
-
       end
 
       # Create the methods related to the attribute to handle the enum type