arel_rest 1.2.1 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '03696f3d7df1d671e416ddc6286525fc21aaeb40241208bdce54a3862324c44a'
-  data.tar.gz: 2bbd4386162c8eef4e4d9cf43206e442f66cb4c34c181a92f1f9439c67819ed8
+  metadata.gz: b16fe311f54f93f520d73d38d672b532d1ede2908aec026d130ff51eecc208d7
+  data.tar.gz: 3b7f1dd29124f3241a33d12d3081879a06196a8ec5843b9533cd31555014c0ae
 SHA512:
-  metadata.gz: c748ceda6d574ccd7ec7b12360f97f5aa54e50dc6eb71902d70471cd74ddd601bd61510b3583cf06ba561dbd8f76d645a79499589e9d9781aaccc7fc4a61b35c
-  data.tar.gz: e3bf8486e07b1877bbebf3df080d55935b4a152e76cd6697abd8acb23678b8ee6fb425c6a4a52ba4daeecaf208fcae1925e402421fe8546ce457df5d6080ca47
+  metadata.gz: 891a2f435f9bcc3c34a00ffe03d89e63f38092dd1caca5bb07f0ed65e87d51c421ea61ab511fcdf49846956f8fd97fc98461eb6980c22a270dee341436ba8833
+  data.tar.gz: 7c9a0a7858e2a44b735923e76a0d7149788dcf553826410240123ebb4494bdf0a8ecacd8fd96fad5f3f7d3d01ec0918de26852afdabc04040d21a4d328125bdb

data/lib/parser.rb

@@ -0,0 +1,83 @@
+require 'predications/eq_operator'
+require 'predications/not_eq_operator'
+require 'predications/gt_operator'
+require 'predications/gteq_operator'
+require 'predications/lt_operator'
+require 'predications/lteq_operator'
+require 'predications/in_operator'
+require 'predications/not_in_operator'
+require 'predications/between_operator'
+require 'predications/matches_operator'
+require 'predications/does_not_match_operator'
+require 'predications/order_operator'
+
+module ArelRest
+	class Parser
+	  TEMPLATE_OPERATORS = {
+	    "eq" => Predications::EqOperator,
+	    "not_eq" => Predications::NotEqOperator,
+	    "gt" => Predications::GtOperator,
+	    "gteq" => Predications::GteqOperator,
+	    "lt" => Predications::LtOperator,
+	    "lteq" => Predications::LteqOperator,
+	    "in" => Predications::InOperator,
+	    "not_in" => Predications::NotInOperator,
+	    "between" => Predications::BetweenOperator,
+	    "matches" => Predications::MatchesOperator,
+	    "does_not_match" => Predications::DoesNotMatchOperator,
+	  }
+
+	  # Recevi object query and return array with
+	  # string query and value.
+	  # Ex: query object: {attribute: "a", operator:"=", values: [1]}
+	  # >> ["a = ?", [1]]
+
+	  class OperatorNotFound < StandardError
+	    attr_accessor :column
+
+	    def initialize(column)
+	      @column = column
+	      super
+	    end
+
+	    def message
+	      "Operator #{@column} not found"
+	    end
+	  end
+
+	  def self.build_pair_query_string_and_values(q)
+	    operator = TEMPLATE_OPERATORS[q[:operator].to_s]
+
+	    raise(Parser::OperatorNotFound, q[:operator].to_s) unless operator
+
+	    operator.process(q)
+	  end
+
+	  def self.query_builder(query)
+	    conector = query.keys.detect{|connector| [:or, :and].include?(connector.to_sym)}
+	    pair_query_string_and_values = query[conector].map do |query_obj|
+	      if query_obj.keys.map(&:to_sym).any?{|key| [:or,:and].include?(key)}
+	        nested_query = query_builder(query_obj) # Recursive
+	        builded = nested_query
+	      else
+	        builded = build_pair_query_string_and_values(query_obj)
+	      end
+
+	      builded
+	    end.inject do |query_composited, query_node|
+	      if query_composited.nil?
+	        query_composited = query_node
+	      else
+	        query_composited = query_composited.send(conector, query_node)
+	      end
+	      query_composited
+	    end
+
+	    pair_query_string_and_values
+	  end
+
+	  def self.parse_filter_to_arel(query)
+	    query_builder(query)
+	  end
+	end
+end

data/lib/predications/between_operator.rb

@@ -0,0 +1,27 @@
+module ArelRest::Predications
+  class BetweenOperator
+    class << self
+      def process(query)
+        table = Arel::Table.new(query[:attribute].split(".")[0])
+        column = query[:attribute].split(".")[1]
+
+        range = Range.new(
+          try_transform_date(query[:values][0]),
+          try_transform_date(query[:values][1])
+          )
+        table[column].between(range)
+      end
+
+      private
+
+      def try_transform_date(date)
+        begin
+          Time.use_zone(ArelRest.time_zone) { Time.parse(date)}
+        rescue StandardError => e
+          date
+        end
+      end
+
+    end
+  end
+end

data/lib/predications/does_not_match_operator.rb

@@ -0,0 +1,11 @@
+module ArelRest::Predications
+  class DoesNotMatchOperator
+    class << self
+      def process(query)
+        table = Arel::Table.new(query[:attribute].split(".")[0])
+        column = query[:attribute].split(".")[1]
+        table[column].does_not_match("%#{query[:values]}%")
+      end
+    end
+  end
+end 

data/lib/predications/eq_operator.rb

@@ -0,0 +1,12 @@
+module ArelRest::Predications
+  class EqOperator
+    class << self
+      def process(query)
+        values = query[:values] == '=null=' ? nil : query[:values]
+
+        table = Arel::Table.new(query[:attribute].split(".")[0])
+        table[query[:attribute].split(".")[1]].eq(values)
+      end
+    end
+  end
+end

data/lib/predications/gt_operator.rb

@@ -0,0 +1,12 @@
+module ArelRest::Predications
+  class GtOperator
+    class << self
+      def process(query)
+        table = Arel::Table.new(query[:attribute].split(".")[0])
+        column = query[:attribute].split(".")[1]
+
+        table[column].gt(query[:values])
+      end
+    end
+  end
+end

data/lib/predications/gteq_operator.rb

@@ -0,0 +1,12 @@
+module ArelRest::Predications
+  class GteqOperator
+    class << self
+      def process(query)
+        table = Arel::Table.new(query[:attribute].split(".")[0])
+        column = query[:attribute].split(".")[1]
+
+        table[column].gteq(query[:values])
+      end
+    end
+  end
+end

data/lib/predications/in_operator.rb

@@ -0,0 +1,12 @@
+module ArelRest::Predications
+  class InOperator
+    class << self
+      def process(query)
+        values = query[:values].dup.map{|value| value==('=null=') ? nil : value}
+
+        table = Arel::Table.new(query[:attribute].split(".")[0])
+        table[query[:attribute].split(".")[1]].in(values)
+      end
+    end
+  end
+end

data/lib/predications/lt_operator.rb

@@ -0,0 +1,12 @@
+module ArelRest::Predications
+  class LtOperator
+    class << self
+      def process(query)
+        table = Arel::Table.new(query[:attribute].split(".")[0])
+        column = query[:attribute].split(".")[1]
+
+        table[column].lt(query[:values])
+      end
+    end
+  end
+end

data/lib/predications/lteq_operator.rb

@@ -0,0 +1,12 @@
+module ArelRest::Predications
+  class LteqOperator
+    class << self
+      def process(query)
+        table = Arel::Table.new(query[:attribute].split(".")[0])
+        column = query[:attribute].split(".")[1]
+
+        table[column].lteq(query[:values])
+      end
+    end
+  end
+end

data/lib/predications/matches_operator.rb

@@ -0,0 +1,10 @@
+module ArelRest::Predications
+  class MatchesOperator
+    class << self
+      def process(query)
+        table = Arel::Table.new(query[:attribute].split(".")[0])
+        table[query[:attribute].split(".")[1]].matches("%#{query[:values]}%")
+      end
+    end
+  end
+end

data/lib/predications/not_eq_operator.rb

@@ -0,0 +1,13 @@
+module ArelRest::Predications
+  class NotEqOperator
+    class << self
+      def process(query)
+        values = query[:values] == '=null=' ? nil : query[:values]
+        
+        table = Arel::Table.new(query[:attribute].split(".")[0])
+        column = query[:attribute].split(".")[1]
+        table[column].not_eq(values)
+      end
+    end
+  end
+end 

data/lib/predications/not_in_operator.rb

@@ -0,0 +1,12 @@
+module ArelRest::Predications
+  class NotInOperator
+    class << self
+      def process(query)
+        values = query[:values].dup.map{|value| value==('=null=') ? nil : value}
+
+        table = Arel::Table.new(query[:attribute].split(".")[0])
+        table[query[:attribute].split(".")[1]].not_in(values)
+      end
+    end
+  end
+end

data/lib/predications/order_operator.rb

@@ -0,0 +1,13 @@
+module ArelRest::Predications
+  class OrderOperator
+    class << self
+      def process(query)
+        table = Arel::Table.new(query[:attribute].split(".")[0])
+        column = query[:attribute].split(".")[1]
+        
+        return table[column].asc if query[:values] == 'asc'
+        return table[column].desc if query[:values] == 'desc'
+      end
+    end
+  end
+end

data/lib/query.rb

@@ -0,0 +1,145 @@
+require "active_support/concern"
+#TODO: Criar uma forma de checar a syntax dos consultas. Ex: Não aceitar dimenssões sem <table_name>.<column>
+module ArelRest
+	module Query
+		extend ActiveSupport::Concern
+		included do
+			WHITE_LIST_MENSURE_OP = {
+				"count" => :count,
+				"average" => :average,
+				"minimum" => :minimum,
+				"maximum" => :maximum,
+				"sum"   => :sum
+			}
+
+			@relationship_tree = {}
+
+			def self.schema
+				@relationship_tree = yield
+			end
+
+			def self.query(_rest_query)
+				# Conditional methods chain
+				self
+				.then do |method_chain| 
+					_rest_query[:filters] ? method_chain.filter(_rest_query[:filters]) :  method_chain
+				end
+				.then do |method_chain| 
+					_rest_query[:sort] ? method_chain.order_by_dimensions(_rest_query[:sort]) :  method_chain
+				end
+				.then do |method_chain| 
+					_rest_query[:dimensions] ? method_chain.group_by_dimensions(_rest_query[:dimensions]) :  method_chain
+				end
+				.then do |method_chain|
+					_rest_query[:page] ? method_chain.offset(_rest_query[:page]) :  method_chain.offset(0)
+				end
+				.then do |method_chain|
+					_rest_query[:size] ? method_chain.limit(_rest_query[:size]) :  method_chain.limit(100)
+				end
+				.then do |method_chain|
+					if _rest_query[:measures]
+						mensure_op = _rest_query[:measures].split('.')[0]
+						column = _rest_query[:measures].split('.')[1]
+						method_chain.send(WHITE_LIST_MENSURE_OP[mensure_op], column)
+					else
+						method_chain
+					end
+				end
+			end
+
+			def self.filter(query)
+				return where({}) unless query.present?
+				query_nodes = ArelRest::Parser.parse_filter_to_arel(query)
+				tables_from_arel_node = collect_tables_from_arel(query_nodes).reject{|table| table == self.table_name}
+
+				paths = tables_from_arel_node.map do |table|
+					build_join_hash find_path_to_relation(relationship_tree, table)
+				end
+				where(query_nodes).joins(paths)
+			end
+
+			def self.group_by_dimensions(query)
+				return group({}) unless query.present?
+				paths = query
+				# TODO: Estudar syntaxe p/ entender se essa extração de nome de tabela é correta
+				.map{|dimension| dimension.split('.')[0]}
+				.map{|table| find_path_to_relation(relationship_tree, table)}.compact
+				.map{|path| build_join_hash path}
+
+				group(query).joins(paths)
+			end
+
+			def self.order_by_dimensions(query)
+				return order({}) unless query.present?
+				paths = query
+				# TODO: Estudar syntaxe p/ entender se essa extração de nome de tabela é correta
+				.keys
+				.map(&:to_s)
+				.map{|dimension| dimension.split('.')[0]}
+				.map{|table| find_path_to_relation(relationship_tree, table)}.compact
+				.map{|path| build_join_hash path}
+
+				order(
+					ArelRest::Predications::OrderOperator
+					.process({
+						attribute: query.keys.first.to_s,
+						values: query.values.first
+					})
+					).joins(paths)
+			end
+
+			def self.relationship_tree
+				@relationship_tree
+			end
+
+			# Busca o caminho até uma associação específica (ex: :comments)
+			def self.find_path_to_relation(tree, target_table, current_path = [])
+				tree.each do |model_name, associations|
+					associations.each do |assoc_name, subtree|
+						table_name_assoc = model_name.to_s.constantize.reflect_on_association(assoc_name).table_name
+						path_with_assoc = current_path + [model_name, assoc_name]
+						return path_with_assoc + [subtree.keys.first] if (table_name_assoc == target_table)
+
+						result = find_path_to_relation(subtree, target_table, path_with_assoc)
+						return result if result
+					end
+				end
+				nil
+			end
+
+			# Converte caminho [:posts, :comments] em hash encadeado { posts: :comments }
+			def self.build_join_hash(path)
+				path ||= []
+				join_path = path.select.with_index { |_, i| i.odd? }
+				join_path.reverse.reduce { |acc, key| { key => acc } }
+			end
+
+			# Recebe um nó(Arel::Node) e busca o nome de todas as tabelas a partir desse nó
+			# TODO: Talvez seja mais fácil obter toda a expressão e obter todas as tabelas a partir
+			# da string
+			def self.collect_tables_from_arel(node, tables = Set.new)
+				return tables unless node.is_a?(Arel::Nodes::Node) || node.is_a?(Arel::Attributes::Attribute)
+
+				# Se for atributo, pega o nome da tabela
+				if node.is_a?(Arel::Attributes::Attribute)
+					tables << node.relation.name.to_s
+				end
+
+				# Percorre children, expressions, left, right, grouping, etc
+				children = []
+				children += node.children if node.respond_to?(:children)
+				children << node.left if node.respond_to?(:left) && node.left
+				children << node.right if node.respond_to?(:right) && node.right
+				children << node.expr if node.respond_to?(:expr) && node.expr
+				children += node.expressions if node.respond_to?(:expressions)
+
+				children.compact.each do |child|
+					collect_tables_from_arel(child, tables)
+				end
+
+				tables
+			end
+
+		end
+	end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: arel_rest
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.3
 platform: ruby
 authors:
 - Luiz Filipe, Lucas Hunter, Leonardo Baptista, Rafael C. Abreu
@@ -109,6 +109,20 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/arel_rest.rb
+- lib/parser.rb
+- lib/predications/between_operator.rb
+- lib/predications/does_not_match_operator.rb
+- lib/predications/eq_operator.rb
+- lib/predications/gt_operator.rb
+- lib/predications/gteq_operator.rb
+- lib/predications/in_operator.rb
+- lib/predications/lt_operator.rb
+- lib/predications/lteq_operator.rb
+- lib/predications/matches_operator.rb
+- lib/predications/not_eq_operator.rb
+- lib/predications/not_in_operator.rb
+- lib/predications/order_operator.rb
+- lib/query.rb
 homepage: https://github.com/luizfilipecosta/arel_rest
 licenses:
 - MIT