babik 0.1.0

data/lib/babik/queryset/components/where.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Common module for Babik library
+module Babik
+  # QuerySet module
+  module QuerySet
+    # Where conditions
+    class Where
+
+      attr_reader :model, :inclusion_filters, :exclusion_filters
+
+      def initialize(model)
+        @model = model
+        @inclusion_filters = []
+        @exclusion_filters = []
+      end
+
+      def exclusion_filters?
+        @exclusion_filters.length.positive?
+      end
+
+      def inclusion_filters?
+        @inclusion_filters.length.positive?
+      end
+
+      def add_exclusion_filter(filter)
+        @exclusion_filters << Babik::QuerySet::Condition.factory(@model, filter)
+      end
+
+      def add_inclusion_filter(filter)
+        @inclusion_filters << Babik::QuerySet::Condition.factory(@model, filter)
+      end
+
+      def left_joins_by_alias
+        left_joins_by_alias = {}
+        [@inclusion_filters, @exclusion_filters].flatten.each do |filter|
+          left_joins_by_alias.merge!(filter.left_joins_by_alias)
+        end
+        left_joins_by_alias
+      end
+    end
+  end
+end

data/lib/babik/queryset/lib/association/foreign_association_chain.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Babik
+  module Association
+
+    # Association chain for association paths
+    # An association chain is a chain of associations
+    # where the target model of association i is the origin model of association i + 1
+    # Remember, an association path is of the form: zone::parent_zone, category::posts::tags
+    class ForeignAssociationChain
+
+      attr_reader :model, :associations, :target_model, :selection_path
+
+      # Construct the association chain
+      # @param model [ActiveRecord::Base] origin model
+      # @param association_path [Array] association path as an array.
+      # @param selection_path [String, Symbol] selection path used only to raise errors.
+      def initialize(model, association_path, selection_path)
+        @model = model
+        @association_path = association_path
+        @selection_path = selection_path
+        _init_associations
+      end
+
+      # Init associations
+      def _init_associations
+        @associations = []
+        associated_model_i = @model
+        @association_path.each do |association_i_name|
+          associated_model_i = _init_association(associated_model_i, association_i_name)
+        end
+        @target_model = associated_model_i
+      end
+
+      # Initialize association by name
+      # @param model [ActiveRecord::Base] origin model of the association association_name
+      # @param association_name [String, Symbol] association name.
+      # @return [ActiveRecord::Base] target model of ith association.
+      def _init_association(model, association_name)
+        association = _assert_association(model, association_name)
+        _association_pass(association)
+      end
+
+      # Each one of the asssociation
+      # @param association_i [AssociationReflection] ith association.
+      # @return [ActiveRecord::Base] target model of ith association.
+      def _association_pass(association_i)
+        # To one relationship
+        if association_i.belongs_to? || association_i.has_one?
+          @associations << association_i
+          return association_i.klass
+        end
+
+        # Many-to-many with through relationship
+        # The has-and-belongs-to-many relationships have been detected and filtered in _construct_association
+
+        # Add model-through association (active_record -> klass)
+        if association_i.through_reflection
+          @associations << association_i.through_reflection
+          # Add through-target association (through -> target)
+          target_name = association_i.source_reflection_name
+          through_model = association_i.through_reflection.klass
+          through_target_association = through_model.reflect_on_association(target_name)
+          @associations << through_target_association
+          # The next association comes from target model
+          return through_target_association.klass
+        end
+
+        # Add direct has_many association
+        @associations << association_i
+        Object.const_get(association_i.class_name)
+      end
+
+      # Return an association or raise an exception if is not an allowed association
+      # @return [Association] Association of model
+      def _assert_association(association_model, association_name)
+        association = association_model.reflect_on_association(association_name.to_sym)
+
+        # Check the association exists
+        unless association
+          raise "Bad selection path: #{@selection_path}. #{association_name} not found "\
+                "in model #{association_model} when filtering #{@model} objects"
+        end
+
+        # Check the association is no a has-and belongs-to-many
+        # These associations are discouraged by Rails Community
+        if association.class == ActiveRecord::Reflection::HasAndBelongsToManyReflection
+          raise "Relationship #{association.name} is has_and_belongs_to_many. Convert it to has_many-through"
+        end
+
+        # Valid association
+        association
+      end
+    end
+
+  end
+end

data/lib/babik/queryset/lib/association/select_related_association_chain.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'babik/queryset/lib/association/foreign_association_chain'
+
+module Babik
+  module Association
+
+    # Association chain for association paths
+    # An association chain is a chain of associations
+    # where the target model of association i is the origin model of association i + 1
+    # Remember, an association path is of the form: zone::parent_zone, category::posts::tags
+    class SelectRelatedAssociationChain < ForeignAssociationChain
+
+      # Each one of the association
+      # @param association_i [AssociationReflection] ith association.
+      # @return [ActiveRecord::Base] target model of ith association.
+      def _association_pass(association_i)
+        # To one relationship
+        if association_i.belongs_to? || association_i.has_one?
+          @associations << association_i
+          associated_model_i = association_i.klass
+          @target_model = associated_model_i
+          return @target_model
+        end
+        raise "Bad association path: #{association_i.name} in model #{association_i.klass} " \
+              "is not belongs_to or has_one when constructing select_related for #{@model} objects"
+      end
+
+    end
+
+  end
+end

data/lib/babik/queryset/lib/condition.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Babik
+  module QuerySet
+    # Each one of the conditions that can appear in a SQL WHERE.
+    module Condition
+
+      # Return the Disjunction or Conjunction according to what class the filters parameter is.
+      # @param model [ActiveRecord::Base] Model owner of this condition.
+      # @param filter [Array, Hash] if it is an Array, it would be a disjunction.
+      #        If a Hash, it would be a conjunction.
+      # @raise [RuntimeError] if the class of filters is not an Array or a Hash.
+      def self.factory(model, filter)
+        if filter.class == Array
+          return Disjunction.new(model, filter.map { |filter_i| Conjunction.new(model, filter_i) })
+        end
+        if filter.class == Hash
+          return Conjunction.new(model, filter)
+        end
+        raise '`filter\' parameter must be an Array for OR-based AND-conditions or a hash for a lone AND-condition'
+      end
+
+      # AND-based condition, also known as conjunction
+      class Conjunction
+        attr_reader :model, :selections
+
+        # Construct a conjunction condition.
+        # @param model [ActiveRecord::Base] Model owner of this condition.
+        # @param filter [Hash] a hash where the key identify field paths and the values the values they must take.
+        def initialize(model, filter)
+          @model = model
+          @selections = []
+          # filter is a Hash composed by :selection_path => value
+          filter.each do |selection_path, value|
+            @selections << Babik::Selection::Base.factory(@model, selection_path, value)
+          end
+        end
+
+        # Return a hash with the joins grouped by alias
+        # @return [Hash] alias: SQL::Join object
+        def left_joins_by_alias
+          left_joins_by_alias_ = {}
+          @selections.each do |selection|
+            left_joins_by_alias_.merge!(selection.left_joins_by_alias)
+          end
+          left_joins_by_alias_
+        end
+
+        # Return SQL code for this conjunction.
+        # e.g
+        #   (first_name = 'Julius' AND last_name = 'Caesar' AND zone = 'Rome')
+        # @return [String] SQL code that will be used in the WHERE part of SQL SELECT statements.
+        def sql
+          @selections.map(&:sql_where_condition).join(" AND\n")
+        end
+      end
+
+    end
+
+    # Disjunction in Disjunctive Normal Form
+    # i.e OR-based condition of AND-based conditions (disjunction of conjunctions)
+    #
+    # See https://en.wikipedia.org/wiki/Disjunctive_normal_form
+    #
+    # e.g.
+    #   (users.filter_name = 'Julius' AND posts.title = 'Stabbed to death: My story') OR
+    #   (users.filter_name = 'Marcus Antonius' AND posts.title = 'A sword in my belly button')
+    #
+    class Disjunction
+      attr_reader :model, :conjunctions
+
+      # Construct a conjunction condition.
+      # @param model [ActiveRecord::Base] Model owner of this condition.
+      # @param conjunctions [Array] array of conjunctions that will be
+      #        joined in a disjunction (hence the name Disjunctive Normal Form).
+      def initialize(model, conjunctions)
+        @model = model
+        @conjunctions = conjunctions
+      end
+
+      # Return a hash with the joins grouped by alias
+      # @return [Hash] alias: SQL::Join object
+      def left_joins_by_alias
+        left_joins_by_alias_ = {}
+        @conjunctions.each do |conjunction|
+          left_joins_by_alias_.merge!(conjunction.left_joins_by_alias)
+        end
+        left_joins_by_alias_
+      end
+
+      # Return SQL code for this disjunction.
+      # e.g
+      #   (first_name = 'Julius' AND last_name = 'Caesar') OR (zone.name = 'Rome')
+      # @return [String] SQL code that will be used in the WHERE part of SQL SELECT statements.
+      def sql
+        "(\n#{@conjunctions.map(&:sql).join(" OR\n")}\n)"
+      end
+    end
+
+  end
+end
+
+

data/lib/babik/queryset/lib/field.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Common module for Babik library
+module Babik
+  module Table
+    # Field module
+    # abstracts the concept of table field according to some useful conversions
+    class Field
+
+      # Create an actual field for a model.
+      # @param model [ActiveRecord::Base] model this field belongs to.
+      # @param field [String] field model that could need the conversion.
+      def initialize(model, field)
+        @model = model
+        @field = field
+      end
+
+      # Check if the field requires some conversion and if that's the case, return the converted final field
+      # If the field is a name of an association, it will be converted to the foreign entity id
+      # @return [String] Actual name of the field that will be used in the SQL.
+      def real_field
+        # If the selected field is a local attribute return the condition as-is (that's the most usual case)
+        is_local_attribute = @model.column_names.include?(@field.to_s)
+        return @field if is_local_attribute
+        # If the selected field is the name of an association, convert it to be a right condition
+        association = @model.reflect_on_association(@field.to_sym)
+        # Only if the association is belongs to, the other associations will be checked by foreign filter method
+        return association.foreign_key if association && association.belongs_to?
+        # Field that is not present in the model
+        raise "Unrecognized field #{@field} for model #{@model} in filter/exclude"
+      end
+    end
+  end
+end

data/lib/babik/queryset/lib/join/association_joiner.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Babik
+  module QuerySet
+    # Join between two tables
+    module Join
+      # Class whose mission is to catch an association path and construct all the sequence of LEFT JOINS
+      # that lies behind this set of associations.
+      class AssociationJoiner
+        attr_reader :left_joins_by_alias, :target_alias
+
+        # Read an Array of associations an construct a list of joins.
+        # @param associations [Array<ActiveRecord::Associations::Association>] Array of associations.
+        def initialize(associations)
+          @left_joins_by_alias = {}
+          last_table_alias = nil
+          associations.each_with_index do |association, association_path_index|
+            # Important, this variable will take the last joined table to chain the join, in the first loop, will take
+            # the association origin table name.
+            last_table_alias ||= association.active_record.table_name
+            left_join = Babik::QuerySet::Join.new_from_association(association, association_path_index, last_table_alias)
+
+            @left_joins_by_alias[left_join.target_alias] = left_join
+            last_table_alias = left_join.target_alias
+          end
+          @target_alias = last_table_alias
+        end
+
+        # Table alias will be another way of calling target alias,
+        #   i.e. the alias of the target table in the join,
+        #   i.e. the alias of the last table in the join,
+        # @return [String] Target table alias
+        def table_alias
+          @target_alias
+        end
+      end
+    end
+  end
+end

data/lib/babik/queryset/lib/join/join.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Babik
+  module QuerySet
+    # Join between two tables
+    module Join
+
+      # Construct a new Join from an association
+      # @param association Association between two ActiveRecord::Base objects.
+      # @param association_position Association position. Used when the relationship is a many-to-many through.
+      # @param origin_table_alias Alias of table that is the origin of the join.
+      # @param join [LeftJoin] Join class.
+      # @return [LeftJoin] object with the join for this association.
+      def self.new_from_association(association, association_position, origin_table_alias, join = LeftJoin)
+        owner_table = association.active_record.table_name
+        target_table_alias = "#{owner_table}__#{association.name}_#{association_position}"
+        join_keys = association.join_keys
+
+        target_table = TargetTable.new(association.table_name, target_table_alias, join_keys.key)
+        origin_table = OriginTable.new(origin_table_alias, join_keys.foreign_key)
+
+        join.new(target_table, origin_table)
+      end
+
+      # A table join
+      class AbstractJoin
+        attr_reader :target_table, :origin_table, :sql
+
+        # Construct a Join
+        # @param target_table [Babik::QuerySet::Join::TargetTable] target table of the join.
+        # @param origin_table [Babik::QuerySet::Join::OriginTable] origin table of the join.
+        def initialize(target_table, origin_table)
+          @target_table = target_table
+          @origin_table = origin_table
+          _init_sql
+        end
+
+        # Initialize SQL of the JOIN
+        def _init_sql
+          # Create the SQL code of the join
+          @sql = %(
+          #{self.class::JOIN_TYPE} JOIN #{@target_table.name} #{@target_table.table_alias}
+              ON #{@target_table.table_alias}.#{@target_table.key} = #{@origin_table.table_alias}.#{@origin_table.key}
+          ).delete("\n").gsub(/\s{2,}/, ' ').strip
+        end
+
+        # Return the target table alias.
+        # @return [String] Target table alias.
+        def target_alias
+          @target_table.table_alias
+        end
+      end
+
+      # Left join between tables
+      class LeftJoin < AbstractJoin
+        JOIN_TYPE = 'LEFT'
+      end
+
+      # Target table of the join
+      class TargetTable
+        attr_reader :name, :table_alias, :key
+        # Constructor
+        # @param name [String] target table name
+        # @param table_alias [String] target table alias
+        # @param key [String] field that serves as key in the target table.
+        def initialize(name, table_alias, key)
+          @name = name
+          @table_alias = table_alias
+          @key = key
+        end
+      end
+
+      # Origin table of the join
+      class OriginTable
+        attr_reader :table_alias, :key
+        # Constructor
+        # @param table_alias [String] origin table alias
+        # @param key [String] field that serves as key.
+        def initialize(table_alias, key)
+          @table_alias = table_alias
+          @key = key
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Babik
+  module Selection
+    # Selection configuration
+    class Config
+      # Relationship separator string
+      # e.g.
+      #  - author::first_name__iregex where author is the association, first_name is the field and iregex the operator
+      #  - posts::tags::name__contains where posts is related with tags and (tag) name is the field
+      #    and contains the operator.
+      RELATIONSHIP_SEPARATOR = '::'
+
+      # Operator separator string
+      # e.g. first_name__iregex where first_name is the field an iregex the operator
+      OPERATOR_SEPARATOR = '__'
+    end
+  end
+end