babik 0.1.0

data/lib/babik/queryset/lib/selection/operation/regex.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'babik/queryset/lib/selection/operation/base'
+
+module Babik
+  module Selection
+    # SQL operation module
+    module Operation
+
+      # Match by case sensitive regex
+      class Regex < Base
+        def initialize(field, value)
+          value = value.inspect[1..-2] if value.class == Regexp
+          value = value[1..-2] if value.class == String && value[0] == '/' && value[-1] == '/'
+          value = _mysql2_convert_regex(value) if db_engine == 'mysql2'
+          super(field, "?field #{operator} ?value", value)
+        end
+
+        def operator
+          dbms_adapter = db_engine
+          return 'REGEXP' if dbms_adapter == 'mysql2'
+          return '~' if dbms_adapter == 'postgresql'
+          return 'REGEXP' if dbms_adapter == 'sqlite3'
+          raise NotImplementedError, "Invalid dbms #{dbms_adapter}. Only mysql, postgresql, and sqlite3 are accepted"
+        end
+
+        def _mysql2_convert_regex(value)
+          replacements = { '\\d' => '[0-9]', '\\w' => '[a-zA-Z]' }
+          replacements.each do |pcre_pattern, mysql_pattern|
+            value = value.gsub(pcre_pattern, mysql_pattern)
+          end
+          value
+        end
+      end
+
+      # Match by case insensitive regex
+      class IRegex < Regex
+
+        def initialize(field, value)
+          value = value.inspect[1..-2] if value.class == Regexp
+          value = value[1..-2] if value.class == String && value[0] == '/' && value[-1] == '/'
+          value = "(?i)#{value}" if db_engine == 'sqlite3'
+          field = "LOWER(#{field})" if db_engine == 'mysql2'
+          super(field, value)
+        end
+
+        def operator
+          dbms_adapter = db_engine
+          return 'REGEXP' if dbms_adapter == 'mysql2'
+          return '~*' if dbms_adapter == 'postgresql'
+          return 'REGEXP' if dbms_adapter == 'sqlite3'
+          raise NotImplementedError, "Invalid dbms #{dbms_adapter}. Only mysql, postgresql, and sqlite3 are accepted"
+        end
+      end
+
+    end
+  end
+end

data/lib/babik/queryset/lib/selection/path/foreign_path.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'babik/queryset/lib/selection/config'
+require 'babik/queryset/lib/join/association_joiner'
+require 'babik/queryset/lib/association/foreign_association_chain'
+
+module Babik
+  module Selection
+    module Path
+      # Foreign path
+      # A foreign path is a succession of associations ending optionally in an operator
+      # if operator is not present, equal is supposed.
+      class ForeignPath
+        RELATIONSHIP_SEPARATOR = Babik::Selection::Config::RELATIONSHIP_SEPARATOR
+        OPERATOR_SEPARATOR = Babik::Selection::Config::OPERATOR_SEPARATOR
+
+        attr_reader :model, :selection_path, :selected_field
+
+        delegate :left_joins_by_alias, to: :@association_joiner
+        delegate :target_alias, to: :@association_joiner
+        delegate :associations, to: :@association_chain
+
+        # Construct a foreign path
+        # A foreign path will be used with a value as a foreign selection to filter
+        # a model with foreign conditions
+        # @param model [ActiveRecord::Base] model that is the object of the foreign path.
+        # @param selection_path [String, Symbol] Association path with an operator. e.g.:
+        #        posts::category__in
+        #        author::posts::tags
+        #        creation_at__date__gte
+        #
+        def initialize(model, selection_path)
+          @model = model
+          @selection_path = selection_path.dup
+          @association_path = selection_path.to_s.split(RELATIONSHIP_SEPARATOR)
+          selection_path = @association_path.pop
+          @selected_field, @operator = selection_path.split(OPERATOR_SEPARATOR)
+          @operator ||= 'equal'
+          _initialize_associations
+        end
+
+        # Initialize associations
+        def _initialize_associations
+          @association_chain = Babik::Association::ForeignAssociationChain.new(@model, @association_path, @selection_path)
+          @association_joiner = Babik::QuerySet::Join::AssociationJoiner.new(@association_chain.associations)
+        end
+      end
+    end
+  end
+end

data/lib/babik/queryset/lib/selection/path/local_path.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'babik/queryset/lib/selection/config'
+
+module Babik
+  module Selection
+    module Path
+
+      # Local path
+      class LocalPath
+        OPERATOR_SEPARATOR = Babik::Selection::Config::OPERATOR_SEPARATOR
+
+        attr_reader :model, :selection_path, :selected_field, :operator, :secondary_operator
+
+        # Construct a local field path
+        # @param model [ActiveRecord::Base] model whose field will be used.
+        # @param selection_path [String] selection path. Of the form <field>__<operator>. e.g. first_name__equal, stars__gt
+        #        If no operator is given (first_name), 'equal' will be used.
+        def initialize(model, selection_path)
+          @model = model
+          @selection_path = selection_path.dup
+          @selected_field, @operator, @secondary_operator = @selection_path.to_s.split(OPERATOR_SEPARATOR)
+          # By default, if no operator is given, 'equal' will be used
+          @operator ||= 'equal'
+        end
+
+        # Return the target table alias.
+        # That is alias of the model table.
+        # For the moment, actually, return the name of this model's table.
+        # @return [String] alias of the model table.
+        def target_alias
+          @model.table_name
+        end
+
+        # A local selection has no related left joins
+        # @return [Hash] Empty hash.
+        def left_joins_by_alias
+          {}
+        end
+
+      end
+    end
+  end
+end

data/lib/babik/queryset/lib/selection/path/path.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'babik/queryset/lib/selection/config'
+require 'babik/queryset/lib/selection/path/foreign_path'
+require 'babik/queryset/lib/selection/path/local_path'
+
+module Babik
+  module Selection
+    module Path
+      # Represents a factory class for ForeignPath & LocalPath
+      class Factory
+
+        # Factory Method used to create local and foreign selections
+        def self.build(model, selection_path)
+          is_foreign = selection_path.match?(Babik::Selection::Config::RELATIONSHIP_SEPARATOR)
+          return Babik::Selection::Path::ForeignPath.new(model, selection_path) if is_foreign
+          Babik::Selection::Path::LocalPath.new(model, selection_path)
+        end
+
+      end
+    end
+  end
+end

data/lib/babik/queryset/lib/selection/select_related_selection.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'babik/queryset/lib/join/association_joiner'
+require 'babik/queryset/lib/join/join'
+require 'babik/queryset/lib/selection/selection'
+require 'babik/queryset/lib/selection/config'
+require 'babik/queryset/lib/association/select_related_association_chain'
+require 'babik/queryset/lib/selection/path/foreign_path'
+
+module Babik
+  module Selection
+
+    # Abstraction of a selection used in select_related operation
+    class SelectRelatedSelection
+      RELATIONSHIP_SEPARATOR = Babik::Selection::Config::RELATIONSHIP_SEPARATOR
+      attr_reader :model, :selection_path, :association_path, :target_model, :id
+
+      delegate :left_joins_by_alias, to: :@association_joiner
+      delegate :target_alias, to: :@association_joiner
+
+      def initialize(model, selection_path)
+        @model = model
+        @selection_path = selection_path.dup
+        @association_path = selection_path.to_s.split(RELATIONSHIP_SEPARATOR)
+        @id = @association_path.join('__')
+
+        _initialize_associations
+        @target_model = @association_chain.target_model
+      end
+
+      def _initialize_associations
+        @association_chain = Babik::Association::SelectRelatedAssociationChain.new(@model, @association_path, @selection_path)
+        @association_joiner = Babik::QuerySet::Join::AssociationJoiner.new(@association_chain.associations)
+      end
+
+    end
+  end
+end

data/lib/babik/queryset/lib/selection/selection.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'babik/queryset/lib/selection/config'
+
+module Babik
+  module Selection
+    # Represents a filter selection (that can be filtered in WHERE)
+    class Base
+
+      # Factory Method used to create local and foreign selections
+      def self.factory(model, selection_path, value)
+        is_foreign_selection = selection_path.match?(Babik::Selection::Config::RELATIONSHIP_SEPARATOR)
+        return Babik::Selection::ForeignSelection.new(model, selection_path, value) if is_foreign_selection
+        Babik::Selection::LocalSelection.new(model, selection_path, value)
+      end
+
+    end
+  end
+end

data/lib/babik/queryset/lib/update/assignment.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+# Common module for Babik library
+module Babik
+  module QuerySet
+    # Update operation module
+    module Update
+      # Field assignment module
+      module Assignment
+        # Return the field prepared for the UPDATE operation.
+        # Used when rendering the SQL template
+        # @param model [ActiveRecord::Base] model this field belongs to.
+        # @param field [String] field to be updated.
+        # @return [String] Field prepared to be inserted in the left part of a SQL UPDATE assignment.
+        def self.sql_field(model, field)
+          field = Babik::Table::Field.new(model, field)
+          field.real_field
+        end
+
+        # Return the value prepared for the UPDATE operation.
+        # Used when rendering the SQL template
+        # @param update_field_value [Operation, Function, String, ActiveRecord::BASE] field to be updated.
+        #        if Operation, an arithmetic operation based on other field of the record will be applied (+, -, * ...)
+        #        if Function, a function will be called.
+        #         The parameters of the function can ben any other field of the record.
+        #        if String, a escaped version of the value will be returned.
+        #        if ActiveRecord::Base, the id of the object will be returned.
+        #        Otherwise, the value as-is will be returned.
+        # @return [String] Field prepared to be inserted in the left part of a SQL UPDATE assignment.
+        def self.sql_value(update_field_value)
+          return update_field_value.sql_value if update_field_value.is_a?(Operation) || update_field_value.is_a?(Function)
+          return _escape(update_field_value) if update_field_value.is_a?(String)
+          return update_field_value.id if update_field_value.is_a?(ActiveRecord::Base)
+          update_field_value
+        end
+
+        # Escape a value for database
+        # @param str [String] original string value.
+        # @return [String] escaped string value.
+        def self._escape(str)
+          Babik::Database.escape(str)
+        end
+
+        # Represents a function operator that can be used in an UPDATE
+        # For example:
+        #   UPDATE SET stars = ABS(stars)
+        class Function
+          def initialize(field, function_call)
+            @field = field
+            @function_call = function_call
+          end
+
+          # Return the right part of the assignment of the UPDATE statement.
+          # @return [String] right part of the assignment with the format defined by the function_call attribute.
+          def sql_value
+            @function_call
+          end
+        end
+
+        # Represents a table field. It will be used when an update field is based on its value an nothing else.
+        # For example:
+        #   UPDATE SET stars = stars + 1
+        class Operation
+          def initialize(field, operation, value)
+            @field = field
+            @operation = operation
+            @value = value
+          end
+
+          # Return the right part of the assignment of the UPDATE statement.
+          # @return [String] right part of the assignment with the format <field> <operation> <value>.
+          def sql_value
+            "#{@field} #{@operation} #{@value}"
+          end
+        end
+
+        # Decrement operation
+        class Decrement < Operation
+          def initialize(field, value = 1)
+            super(field, '-', value)
+          end
+        end
+
+        # Increment operation
+        class Increment < Operation
+          def initialize(field, value = 1)
+            super(field, '+', value)
+          end
+        end
+
+        # Multiplication operation
+        class Multiply < Operation
+          def initialize(field, value)
+            super(field, '*', value)
+          end
+        end
+
+        # Division operation
+        class Divide < Operation
+          def initialize(field, value)
+            super(field, '/', value)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Babik
+  module QuerySet
+    # Functionality related to the aggregation selection
+    module Aggregatable
+      # Aggregate a set of objects.
+      # @param agg_functions [Hash{symbol: Babik.agg}] hash with the different aggregations that will be computed.
+      # @return [Hash{symbol: float}] Result of computing each one of the aggregations.
+      def aggregate(agg_functions)
+        @_aggregation = Babik::QuerySet::Aggregation.new(@model, agg_functions)
+        select_sql = sql.select
+        self.class._execute_sql(select_sql).first.transform_values(&:to_f).symbolize_keys
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Babik
+  module QuerySet
+    # Every QuerySet is bounded by its first and last items
+    module Bounded
+
+      # Return the first element given some order
+      # @param order [Array, String, Hash] ordering that will be applied to the QuerySet.
+      #              See {Babik::QuerySet::Sortable#order_by}.
+      # @return [ActiveRecord::Base] First element according to the order.
+      def earliest(*order)
+        self.order_by(*order).first
+      end
+
+      # Return the first element of the QuerySet.
+      # @return [ActiveRecord::Base] First element of the QuerySet.
+      def first
+        self.all.first
+      end
+
+      # Return the last element of the QuerySet.
+      # @return [ActiveRecord::Base] Last element of the QuerySet.
+      def last
+        self.invert_order.all.first
+      end
+
+      # Return the last element given some order
+      # @param order [Array, String, Hash] ordering that will be applied to the QuerySet.
+      #              See {Babik::QuerySet::Sortable#order_by}.
+      # @return [ActiveRecord::Base] Last element according to the order.
+      def latest(*order)
+        self.order_by(*order).last
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'deep_clone'
+
+module Babik
+  module QuerySet
+    # Clone operation for the QuerySet
+    module Clonable
+
+      # Clone the queryset using ruby_deep_clone {https://github.com/gmodarelli/ruby-deepclone}.
+      # @return [QuerySet] Deep copy of this QuerySet.
+      def clone
+        DeepClone.clone(self)
+      end
+
+      # Clone this QuerySet and apply the 'mutator_method' to it.
+      # @param mutator_method [Symbol] Name of the method.
+      # @param parameters [Array] Parameters passed to the method
+      # @return [QuerySet] The resultant QuerySet of applying the mutator to the clone of the caller object.
+      def mutate_clone(mutator_method, parameters = [])
+        clone_ = clone
+        if parameters.empty?
+          clone_.send(mutator_method)
+        else
+          clone_.send(mutator_method, *parameters)
+        end
+        clone_
+      end
+
+      # Check if the called method has a modifying version (a bang method). If that is the case
+      # it will be called on a clone of this instance. Otherwise, super will be called.
+      # @param name [String] method name
+      # @param args [String] method arguments
+      # @param _block [Proc] Proc that could be passed to the method. Not used.
+      # @return [QuerySet] Clone of this QuerySet (with method 'name' called on ), an empty QuerySet.
+      def method_missing(name, *args, &_block)
+        modifying_method = "#{name}!"
+        return mutate_clone(modifying_method.to_sym, args) if self.respond_to?(modifying_method)
+        super
+      end
+
+      # Check if the called method has a modifying version (a bang method).
+      # @return [Boolean] True if  there is a modifying method with the requested method name
+      #         in that case, return true, otherwise, return false.
+      def respond_to_missing?(name, *_args, &_block)
+        modifying_method = "#{name}!"
+        self.respond_to?(modifying_method)
+      end
+
+    end
+  end
+end