arel_rest 1.2.0 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ee49e7798d3993c59f1a6dda599ad59cf877d36a804599129b77d215ad19b0a
-  data.tar.gz: 99fbc3f2396d126d2c8adf56e6dcf48adbdc2b92c3e5097017889daac063b32f
+  metadata.gz: 248cd74204296375871f7e5de8358609ebf10042f25b2bd542fac98ccc69f332
+  data.tar.gz: ece38b072cff0716453e5a97b1a4f8a1296a3366e7ac06e64d3d6297f9dbbf18
 SHA512:
-  metadata.gz: d5725e9cc6ba379690e92322e9e09fdcb98bdb23b66e6dbe12fd18bf2325f8974980d1497d58fb1f3f3b1212ec3ebfd04342d39e63587844fcd4badae4db03e0
-  data.tar.gz: b115e38a53480c8030c1916f4bd35c0d1b76872d5548ed508d1dc04f0d0f9f15e727a66bcb90e20a2a4389e6c601b5c83fb1e677d8d5902fa8bc61cf73ec223e
+  metadata.gz: 54b64f1e8678c878a5152d9a24479602380f2a612483ac6370d9218e24e927c40f64a80bed6f4684390054c8b57862851aa5bd5712355c8af9c48aca74143293
+  data.tar.gz: 85054aa333add5050dcb2e2edbda9de70da7422d255a0f33f7df324d19da550f0972a9acab3687618f09cda9a4cb72b5a3d0187992be3d14477ddf688f2eb528

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,46 @@
+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(
+          transform_data_for_first(query[:values][0]),
+          transform_data_for_last(query[:values][1])
+          )
+        table[column].between(range)
+      end
+
+      private
+
+      def transform_data_for_first(first)
+        # Try obtein date in format iso8601
+        case first
+        when /^\d{4}-\d{2}-\d{2}$/ # somente com data
+          Time.use_zone(ArelRest.time_zone) { Time.zone.parse(first).beginning_of_day }
+        when /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/ # com data e hora
+          Time.use_zone(ArelRest.time_zone) { Time.zone.parse(first) }
+        when /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(Z|[+-]\d{2}:\d{2})$/ # com data, hora e fuso horário
+          Time.use_zone(ArelRest.time_zone) { Time.zone.parse(first) }
+        else
+          first
+        end
+      end
+
+      def transform_data_for_last(last)
+        case last
+        when /^\d{4}-\d{2}-\d{2}$/ # somente com data
+          Time.use_zone(ArelRest.time_zone) { Time.zone.parse(last).beginning_of_day }
+        when /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/ # com data e hora
+          Time.use_zone(ArelRest.time_zone) { Time.zone.parse(last) }
+        when /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(Z|[+-]\d{2}:\d{2})$/ # com data, hora e fuso horário
+          Time.use_zone(ArelRest.time_zone) { Time.zone.parse(last) }
+        else
+          last
+        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.0
+  version: 1.2.2
 platform: ruby
 authors:
 - Luiz Filipe, Lucas Hunter, Leonardo Baptista, Rafael C. Abreu
@@ -14,28 +14,22 @@ dependencies:
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '6'
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '7'
-    - - "~>"
+        version: '6.0'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '8'
+        version: '9.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '6'
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '7'
-    - - "~>"
+        version: '6.0'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '8'
+        version: '9.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -115,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