babik 0.1.0

data/lib/babik/queryset/mixins/countable.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Babik
+  module QuerySet
+    # Functionality related to the size of the QuerySet
+    module Countable
+
+      # Return the number of elements that match the condition defined by successive calls of filter and exclude.
+      # @return [Integer] Number of elements that match the condition defined in this QuerySet.
+      def count
+        self.all.count
+      end
+
+      # Inform if the QuerySet has no elements that match the condition.
+      # @return [Boolean] True if no records match the filter, false otherwise.
+      def empty?
+        self.count.zero?
+      end
+
+      # Inform if the QuerySet has at least one element that match the condition.
+      # @return [Boolean] True if one or more records match the filter, false otherwise.
+      def exists?
+        self.count.positive?
+      end
+
+      # Return the number of elements that match the condition defined by successive calls of filter and exclude.
+      # Alias of count.
+      # @see Babik::QuerySet::Countable#count
+      # @return [Integer] Number of elements that match the condition defined in this QuerySet.
+      def length
+        self.count
+      end
+
+      # Return the number of elements that match the condition defined by successive calls of filter and exclude.
+      # Alias of count.
+      # @see Babik::QuerySet::Countable#count
+      # @return [Integer] Number of elements that match the condition defined in this QuerySet.
+      def size
+        self.count
+      end
+
+    end
+  end
+end

data/lib/babik/queryset/mixins/deletable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Babik
+  module QuerySet
+    # Functionality related to the DELETE operation
+    module Deletable
+      # Delete the selected records
+      def delete
+        result = @model.connection.execute(sql.delete)
+      end
+    end
+  end
+end

data/lib/babik/queryset/mixins/distinguishable.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Babik
+  module QuerySet
+    # Distinguishable functionality for QuerySet
+    module Distinguishable
+
+      # Mark this QuerySet as distinguishable.
+      # Modify this object
+      # (i.e. DISTINCT keyword will be applied to the final SQL query).
+      # @return [QuerySet] Reference to this QuerySet.
+      def distinct!
+        @_distinct = true
+        self
+      end
+
+      # Mark this QuerySet as not distinguishable
+      # (i.e. DISTINCT keyword will NOT be applied to query).
+      # @return [QuerySet] Reference to this QuerySet.
+      def undistinct!
+        @_distinct = false
+        self
+      end
+
+    end
+  end
+end

data/lib/babik/queryset/mixins/filterable.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Babik
+  module QuerySet
+    # Functionality related to the DELETE operation
+    module Filterable
+      # Exclude objects according to some criteria.
+      # @return [QuerySet] Reference to self.
+      def exclude!(filter)
+        _filter(filter, 'exclusion')
+        self
+      end
+
+      # Select objects according to some criteria.
+      # @param filter [Array, Hash] if array, it is considered an disjunction (OR clause),
+      #        if a hash, it is considered a conjunction (AND clause).
+      # @return [QuerySet] Reference to self.
+      def filter!(filter)
+        _filter(filter, 'inclusion')
+        self
+      end
+
+      # Get an single element
+      # @param filter [Array, Hash] if array, it is considered an disjunction (OR clause),
+      #        if a hash, it is considered a conjunction (AND clause).
+      # @raise [RuntimeError] Exception:
+      #        'Multiple objects returned' if more than one object matches the condition.
+      #        'Does not exist' if no object match the conditions.
+      # @return [ActiveRecord::Base] object that matches the filter.
+      def get(filter)
+        result_ = self.filter(filter).all
+        result_count = result_.count
+        raise 'Does not exist' if result_count.zero?
+        raise 'Multiple objects returned' if result_count > 1
+        result_.first
+      end
+
+      private
+
+      # Select the objects according to some criteria.
+      # @param filter [Array, Hash] if array, it is considered an disjunction (OR clause),
+      #        if a hash, it is considered a conjunction (AND clause).
+      # @param filter_type [String] Filter type. Must be 'inclusion' or 'exclusion'.
+      # @raise [NoMethodError] if filter_type is not 'inclusion' nor 'exclusion'.
+      def _filter(filter, filter_type)
+        @_where.send("add_#{filter_type}_filter", filter)
+      end
+
+    end
+  end
+end

data/lib/babik/queryset/mixins/limitable.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Babik
+  module QuerySet
+    # Limit functionality of QuerySet
+    module Limitable
+
+      # Configure a limit this QuerySet
+      # @param param [Range, Integer]
+      #        If it is a range, first_element..last_element will be selected.
+      #        If it is an integer, the element in that position will be returned. No negative number is allowed.
+      # @raise RuntimeError 'Invalid limit passed to query: <VALUE>' If param is not a Range or Integer.
+      # @return [QuerySet, ActiveRecord::Base] QuerySet if a slice was passe as parameter,
+      #         otherwise an ActiveRecord model.
+      def [](param)
+        raise "Invalid limit passed to query: #{param}" unless [Range, Integer].include?(param.class)
+        self.clone.send("limit_#{param.class.to_s.downcase}!", param)
+      end
+
+      # Inform if at least one record is matched by this QuerySet
+      # @return [Boolean] True if at least one record matches the conditions of the QuerySet, false otherwise.
+      def exists?
+        element = self.fetch(0, false)
+        return true if element
+        false
+      end
+
+      # Return an element at an index, otherwise:
+      # - Return a default value if it has been passed as second argument.
+      # - Raise an IndexError exception
+      # @param index [Integer] Position of the element want to return. No negative number is allowed.
+      # @param default_value [Object] Anything that will be returned if no record is found at the index position.
+      #        By default it takes a nil value (in that case, it will raise the IndexError exception).
+      # @raise [IndexError] When there is no default value
+      def fetch(index, default_value = nil)
+        element = self.[](index)
+        return element if element
+        return default_value unless default_value.nil?
+        raise IndexError, "Index #{index} outside of QuerySet bounds"
+      end
+
+      # Configure a limit this QuerySet
+      # @param size [Integer] Number of elements to be selected.
+      # @param offset [Integer] Position where the selection will start. By default is 0. No negative number is allowed.
+      # @return [QuerySet] Reference to this QuerySet.
+      def limit!(size, offset = 0)
+        @_limit = Babik::QuerySet::Limit.new(size, offset)
+        self
+      end
+
+      # Inform if this QuerySet is limited
+      # @return [Boolean] true if this QuerySet has a limit, false otherwise.
+      def limit?
+        @_limit && true
+      end
+
+      # Destroy the current limit of this QuerySet
+      # @return [QuerySet] Reference to this QuerySet.
+      def unlimit!
+        @_limit = nil
+        self
+      end
+
+      private
+
+      # Get one element at a determined position
+      # @param position [Integer] Position of the element to be returned.
+      # @api private
+      # @return [ActiveRecord::Base, nil] ActiveRecord::Base if exists a record in that position, nil otherwise.
+      def limit_integer!(position)
+        @_limit = Babik::QuerySet::Limit.new(1, position)
+        self.first
+      end
+
+      # Get a QuerySet with a slice of the original QuerySet
+      # @param param [Range] first_element..last_element will be selected.
+      # @api private
+      # @return [QuerySet] QuerySet with a slice of the caller QuerySet.
+      def limit_range!(param)
+        offset = param.min
+        size = param.max.to_i - param.min.to_i
+        @_limit = Babik::QuerySet::Limit.new(size, offset)
+        self
+      end
+
+    end
+  end
+end

data/lib/babik/queryset/mixins/lockable.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Babik
+  module QuerySet
+    # Lock functionality of QuerySet
+    module Lockable
+
+      # Lock the table for writes
+      # This must be inside a transaction
+      def for_update!
+        @_lock_type = 'FOR UPDATE'
+        self
+      end
+
+      # Lock the table for writes
+      # This must be inside a transaction
+      # @see #for_update Alias of for_update method
+      def lock!
+        self.for_update!
+      end
+
+      # Check if there is a lock
+      # @return [Boolean] True if there is a lock, false otherwise.
+      def lock?
+        return true if @_lock_type
+        false
+      end
+
+    end
+  end
+end

data/lib/babik/queryset/mixins/none.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Babik
+  module QuerySet
+    # None functionality for QuerySet
+    module NoneQuerySet
+
+      # Return an empty ActiveRecord ResultSet
+      # @return [ResultSet] Empty result set.
+      def none
+        @model.find_by_sql("SELECT * FROM #{@model.table_name} WHERE 1 = 0")
+      end
+
+    end
+  end
+end

data/lib/babik/queryset/mixins/projectable.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Babik
+  module QuerySet
+    # Project functionality of QuerySet
+    module Projectable
+
+      # Prepares a projection of only some attributes
+      # @param *attributes [Array] Attributes that will be projected.
+      #        Each one of these can be a local field, or a foreign entity field.
+      #        Babik will take care of joins.
+      # @return [QuerySet] Reference to this QuerySet.
+      def project!(*attributes)
+        @_projection = Babik::QuerySet::Projection.new(@model, attributes)
+        self
+      end
+
+      # Removes the projection.
+      # @return [QuerySet] Reference to this QuerySet.
+      def unproject!
+        @_projection = nil
+        self
+      end
+
+      # Inform if there is the QuerySet is configured with a projection
+      # @return [Boolean] True if there is a projection configured, false otherwise.
+      def projection?
+        return true if @_projection
+        false
+      end
+
+    end
+  end
+end

data/lib/babik/queryset/mixins/related_selector.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Babik
+  module QuerySet
+
+    # select_related functionality of QuerySet
+    module RelatedSelector
+
+      # Load the related objects of each model object specified by the association_paths
+      #
+      # e.g.
+      # - User.objects.filter(first_name: 'Julius').select_related(:group)
+      # - User.objects.filter(first_name: 'Cassius').select_related([:group, :zone])
+      # - Post.objects.select_related(:author)
+      #
+      # @param association_paths [Array<Symbol>, Symbol] Array of association paths
+      #        of belongs_to and has_one related objects.
+      #        A passed symbol will be considered as an array of one symbol.
+      #        That is, select_related(:group) is equal to select_related([:group])
+      def select_related!(association_paths)
+        @_select_related = Babik::QuerySet::SelectRelated.new(@model, association_paths)
+        self
+      end
+
+    end
+
+  end
+end

data/lib/babik/queryset/mixins/set_operations.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Babik
+  module QuerySet
+    # Set operations over QuerySets
+    module SetOperations
+
+      # Difference (minus) operation
+      # @param other_queryset [QuerySet] Other QuerySet
+      # @return [Babik::QuerySet::Except] Except set operation between this queryset and the other queryset.
+      def difference(other_queryset)
+        Babik::QuerySet::Except.new(self.model, self, other_queryset)
+      end
+
+      # Intersection (except) operation
+      # @param other_queryset [QuerySet] Other QuerySet
+      # @return [Babik::QuerySet::Intersect] Intersection set operation between this queryset and the other queryset.
+      def intersection(other_queryset)
+        Babik::QuerySet::Intersect.new(self.model, self, other_queryset)
+      end
+
+      # Union operation
+      # @param other_queryset [QuerySet] Other QuerySet
+      # @return [Babik::QuerySet::Union] Union set operation between this queryset and the other queryset.
+      def union(other_queryset)
+        Babik::QuerySet::Union.new(self.model, self, other_queryset)
+      end
+
+    end
+  end
+end
+

data/lib/babik/queryset/mixins/sortable.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Babik
+  module QuerySet
+    # Sort functionality of QuerySet
+    module Sortable
+
+      # Sort QuerySet according to an order
+      # @param order [Array, String, Hash] ordering that will be applied to the QuerySet.
+      #        See {Babik::QuerySet::Order#order_by}.
+      # @return [QuerySet] reference to this QuerySet.
+      def order_by!(*order)
+        @_order = Babik::QuerySet::Order.new(@model, *order)
+        self
+      end
+
+      # Remove the order on this QuerySet according to an order
+      # @return [QuerySet] reference to this QuerySet.
+      def disorder!
+        @_order = nil
+        self
+      end
+
+      # Alias for order_by
+      # @see #order_by
+      # @param order [Array, String, Hash] ordering that will be applied to the QuerySet.
+      # @return [QuerySet] reference to this QuerySet.
+      def order!(*order)
+        order_by!(*order)
+      end
+
+      # Invert the order
+      # e.g.
+      #   first_name ASC, last_name ASC, created_at DESC => invert => first_name DESC, last_name DESC, created_at ASC
+      # @return [QuerySet] reference to this QuerySet.
+      def invert_order!
+        @_order.invert!
+        self
+      end
+
+      # Inform if there is an order for this QuerySet
+      # @return [Boolean] True if this QuerySet is ordered, false otherwise.
+      def ordered?
+        return true if @_order
+        false
+      end
+    end
+  end
+end

data/lib/babik/queryset/mixins/sql_renderizable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Babik
+  module QuerySet
+    # Enumerable functionality for QuerySet
+    module SQLRenderizable
+
+      # Get the SQL renderer for this QuerySet.
+      # @return [QuerySet] SQL Renderer for this QuerySet.
+      def sql
+        renderer = SQLRenderer.new(self)
+        renderer
+      end
+
+    end
+  end
+end