sql_query_executor 0.3.2 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 69f41682d9033acdb640a38d097d9f99eb13cabd
-  data.tar.gz: 3a0b636c3771ca0fbece8a6a9cfef45df2abca80
+  metadata.gz: 885c973bd56f42cacc7f5a2ec53399c6004aa487
+  data.tar.gz: a5591b1baddeb58afd77ac9279f82b8eca4f3213
 SHA512:
-  metadata.gz: 535d00055be485560c0c2a41e4dab3ddf16cb4d462f5656cdc40f84a65838e6a003c37076fb5d68f0c58488bd2908b83c9ac783327644ebb1e03c3c0410e1299
-  data.tar.gz: c353d5a6f9b4e55cfb2c0a5fd868e10f205539a6d5a6fd0f400eb3d7e2d731b9b595bea31b6423c88386221fe92de36dba58661f28de9e6a86e2f4e85fba5a00
+  metadata.gz: 59120a2dc4c1468f86b4bef599daf7b2601c8e30164cfb427397559656320163a1bc80a0b29c3e6d96f4649047e3e4823c5c49d2b356a2304c322f45484acb3f
+  data.tar.gz: 32a3793e8c462c62719c37ebf5900ecae59130831f33216c36bc8e4165a5e45439c146c2569181febcac63c7afcce50d5b90ed6ac115a15c631d2d318c34b22a

data/lib/sql_query_executor/base.rb

@@ -16,7 +16,7 @@ module SqlQueryExecutor #:nodoc:
       raise ArgumentError.new(message) if message
 
       get_collection(collection)
-      query = Query::QueryNormalizer.execute(query)
+      query = Query::Normalizers::QueryNormalizer.execute(query)
       @query = SqlQueryExecutor::Query::SubQuery.new query, @collection
     end
 

data/lib/sql_query_executor/operators/base.rb

@@ -4,7 +4,7 @@ module SqlQueryExecutor
   module Operators
     class Base
       def initialize(query, collection)
-        @query      = SqlQueryExecutor::Query::QueryNormalizer.execute(query).gsub(SqlQueryExecutor::Base::QUERY_SPACE, ' ')
+        @query      = SqlQueryExecutor::Query::Normalizers::QueryNormalizer.execute(query).gsub(SqlQueryExecutor::Base::QUERY_SPACE, ' ')
         @collection = collection
         @array      = @query.split(' ')
         @operator   = @query.split(' ')[1]

data/lib/sql_query_executor/query/normalizers/base_normalizer.rb

@@ -2,21 +2,53 @@ require 'sql_query_executor'
 
 module SqlQueryExecutor
   module Query
-    class BaseNormalizer
-    private
-      # Returns converted #param based on its Class, so it can be used on the query
-      def self.convert_param(param)
-        case param.class.name
-        when "NilClass"
-          nil
-        when "String"
-          "'#{param}'".gsub("''", "'").gsub('""', '"')
-        when "Date"
-          "'#{param.strftime("%Y-%m-%d")}'"
-        when "Time"
-          "'#{param.strftime("%Y-%m-%d %H:%M:%S %z")}'"
-        else
-          param.to_s
+    module Normalizers
+      class BaseNormalizer
+      private
+        # Returns converted #param based on its Class, so it can be used on the query
+        def self.convert_param(param)
+          case param.class.name
+          when "NilClass"
+            nil
+          when "String"
+            "'#{param}'".gsub("''", "'").gsub('""', '"')
+          when "Date"
+            "'#{param.strftime("%Y-%m-%d")}'"
+          when "Time"
+            "'#{param.strftime("%Y-%m-%d %H:%M:%S %z")}'"
+          else
+            param.to_s
+          end
+        end
+
+        def self.attributes_from_query(selector)
+          return {} if selector.empty?
+
+          attributes = {}
+
+          selector.each do |key, value|
+            case value.class.name
+            when 'Array'
+              attributes.merge!(attributes_from_array(value)) if key == '$and'
+            when 'Hash'
+              attributes.merge!(attributes_from_query(value))
+            else
+              attributes[key.to_sym] = value unless key.to_s.include?('$')
+            end
+          end
+
+          attributes
+        end
+
+      protected
+        def self.attributes_from_array(array)
+          attributes = {}
+
+          array.each do |hash|
+            attributes.merge!(attributes_from_query(hash))
+          end
+
+          attributes
         end
       end
     end

data/lib/sql_query_executor/query/normalizers/origin_normalizer.rb

@@ -3,60 +3,62 @@ require 'sql_query_executor/query/normalizers/base_normalizer'
 
 module SqlQueryExecutor
   module Query
-    class OriginNormalizer < BaseNormalizer
-      BINDING_OPERATORS = ['$and', '$or']
-      OPERATORS = {
-                    "$gt" => '>',
-                    "$lt" => '<',
-                    "$gte" => '>=',
-                    "$lte" => '<=',
-                    "$ne" => '!=',
-                    "$in" => 'in'
-                  }
-
-      def self.execute(query)
-        query_array = []
-
-        query.each do |key, value|
-          if value.is_a?(Array)
-            query_array << hash_with_array_value(key, value)
-          else
-            query_array << normal_hash(key, value)
+    module Normalizers
+      class OriginNormalizer < BaseNormalizer
+        BINDING_OPERATORS = ['$and', '$or']
+        OPERATORS = {
+                      "$gt" => '>',
+                      "$lt" => '<',
+                      "$gte" => '>=',
+                      "$lte" => '<=',
+                      "$ne" => '!=',
+                      "$in" => 'in'
+                    }
+
+        def self.execute(query)
+          query_array = []
+
+          query.each do |key, value|
+            if value.is_a?(Array)
+              query_array << hash_with_array_value(key, value)
+            else
+              query_array << normal_hash(key, value)
+            end
           end
-        end
 
 
-        query_array.join(" and ").gsub('!=', '<>')
-      end
+          query_array.join(" and ").gsub('!=', '<>')
+        end
 
-    private
-      def self.hash_with_array_value(key, value)
-        if BINDING_OPERATORS.include?(key)
-          key = key.gsub('$', '')
-          queries = []
+      private
+        def self.hash_with_array_value(key, value)
+          if BINDING_OPERATORS.include?(key)
+            key = key.gsub('$', '')
+            queries = []
 
-          value.each do |hash|
-            queries << execute(hash)
-          end
+            value.each do |hash|
+              queries << execute(hash)
+            end
 
-          "(#{queries.join(" #{key.to_s} ")})"
-        else
-          value = value.first.is_a?(Numeric) ? value : value.map{ |v| "'#{v}'" }
-          "#{key} in (#{value.join(',')})"
+            "(#{queries.join(" #{key.to_s} ")})"
+          else
+            value = value.first.is_a?(Numeric) ? value : value.map{ |v| "'#{v}'" }
+            "#{key} in (#{value.join(',')})"
+          end
         end
-      end
 
-      def self.normal_hash(key, value)
-        operator = '='
+        def self.normal_hash(key, value)
+          operator = '='
 
-        if value.is_a?(Hash)
-          operator = OPERATORS[value.keys.first] || operator
+          if value.is_a?(Hash)
+            operator = OPERATORS[value.keys.first] || operator
 
-          value = convert_param(value.values.first)
-        end
+            value = convert_param(value.values.first)
+          end
 
-        value = convert_param(value)
-        value.nil? ? "#{key} is null" : "#{key} #{operator} #{value}"
+          value = convert_param(value)
+          value.nil? ? "#{key} is null" : "#{key} #{operator} #{value}"
+        end
       end
     end
   end

data/lib/sql_query_executor/query/normalizers/query_normalizer.rb

@@ -4,92 +4,100 @@ require 'sql_query_executor/query/normalizers/origin_normalizer'
 
 module SqlQueryExecutor
   module Query
-    class QueryNormalizer < BaseNormalizer
-      CONVERT_METHODS = {"String" => "get_query", "Array" => "interpolate_query", "Hash" => "convert_hash"}
+    module Normalizers
+      class QueryNormalizer < BaseNormalizer
+        CONVERT_METHODS = {"String" => "get_query", "Array" => "interpolate_query", "Hash" => "convert_hash"}
 
-      def self.execute(query)
-        query = clean_query_attribute(query)
-        method = CONVERT_METHODS[query.class.name]
+        def self.execute(query)
+          query = clean_query_attribute(query)
+          method = CONVERT_METHODS[query.class.name]
 
-        query = sanitize(send(method, query))
-      end
+          query = sanitize(send(method, query))
+        end
 
-      def self.clean_query(query)
-        remove_placeholders execute(query).gsub('!=', '<>')
-      end
+        def self.clean_query(query)
+          remove_placeholders execute(query).gsub('!=', '<>')
+        end
 
-    private
-      def self.convert_hash(query)
-        OriginNormalizer.execute(query)
-      end
+        def self.attributes_from_query(query)
+          return {} if query.empty?
+          selector = query.class == Hash ? query : Base.new([], query).selector
+          super(selector)
+        end
 
-      def self.remove_placeholders(query)
-        query.gsub(Base::QUERY_SPACE, ' ').gsub(Base::STRING_SPACE, ' ').gsub(Base::TEMP_SPACE, ' ')
-      end
+      private
+        def self.convert_hash(query)
+          OriginNormalizer.execute(query)
+        end
 
-      def self.clean_query_attribute(query)
-        return query unless query.is_a?(Array)
+        def self.remove_placeholders(query)
+          query.gsub(Base::QUERY_SPACE, ' ').gsub(Base::STRING_SPACE, ' ').gsub(Base::TEMP_SPACE, ' ')
+        end
 
-        query = query.flatten
+        def self.clean_query_attribute(query)
+          return query unless query.is_a?(Array)
 
-        (query.size == 1 ? query.first : query)
-      end
+          query = query.flatten
 
-      def self.get_query(query)
-        query
-      end
+          (query.size == 1 ? query.first : query)
+        end
 
-      # Prepares query by replacing all ? by it's real values in #args
-      def self.interpolate_query(args)
-        args.flatten!
-        return args.first if args.size == 1 && args.first.is_a?(String)
+        def self.get_query(query)
+          query
+        end
 
-        query = args.first
-        param = args.delete_at(1)
+        # Prepares query by replacing all ? by it's real values in #args
+        def self.interpolate_query(args)
+          args.flatten!
+          return args.first if args.size == 1 && args.first.is_a?(String)
 
-        param = convert_param(param)
+          query = args.first
+          param = args.delete_at(1)
 
-        args[0] = query.sub("?", param.is_a?(Numeric) ? param : "#{param}")
+          param = convert_param(param)
 
-        interpolate_query(args)
-      end
+          args[0] = query.sub("?", param.is_a?(Numeric) ? param : "#{param}")
 
-      # Removes all accents and other non default characters
-      def self.sanitize(query)
-        new_query = replace_on_query(query, /(["|'].*?["|'])/, " ", Base::STRING_SPACE)
-        new_query = replace_on_query(new_query, /(\(.*?\))/, " ", Base::QUERY_SPACE)
+          interpolate_query(args)
+        end
 
-        remove_spaces(prepare_query(new_query))
-      end
+        # Removes all accents and other non default characters
+        def self.sanitize(query)
+          new_query = replace_on_query(query, /(["|'].*?["|'])/, " ", Base::STRING_SPACE)
+          new_query = replace_on_query(new_query, /(\(.*?\))/, " ", Base::QUERY_SPACE)
 
-      def self.replace_on_query(query, regexp, pattern, replacement)
-        new_query = query ? query.dup : query
+          remove_spaces(prepare_query(new_query))
+        end
 
-        params = new_query.scan(regexp).flatten.compact
+        def self.replace_on_query(query, regexp, pattern, replacement)
+          new_query = query ? query.dup : query
 
-        params.each do |param|
-          new_param = param.dup
+          params = new_query.scan(regexp).flatten.compact
 
-          new_param = new_param.gsub(pattern, replacement)
+          params.each do |param|
+            new_param = param.dup
 
-          new_query = new_query.gsub(param, new_param)
-        end
+            new_param = new_param.gsub(pattern, replacement)
 
-        new_query
-      end
+            new_query = new_query.gsub(param, new_param)
+          end
 
-      def self.prepare_query(query)
-        SubQuery::BINDING_OPERATORS.keys.each do |operator|
-          query.gsub!(" #{operator} ", "#{Base::TEMP_SPACE}#{operator}#{Base::QUERY_SPACE}")
+          new_query
         end
 
-        query.gsub(" ", Base::QUERY_SPACE).gsub(Base::TEMP_SPACE, " ")
-      end
+        def self.prepare_query(query)
+          SubQuery::BINDING_OPERATORS.keys.each do |operator|
+            query.gsub!(" #{operator} ", "#{Base::TEMP_SPACE}#{operator}#{Base::QUERY_SPACE}")
+          end
 
-      def self.remove_spaces(query)
-        query.gsub!(",#{Base::QUERY_SPACE}", ',')
-        query.gsub!(/\[.*?\]/) { |substr| substr.gsub(' ', '') }
-        query
+          query.gsub(" ", Base::QUERY_SPACE).gsub(Base::TEMP_SPACE, " ")
+        end
+
+        def self.remove_spaces(query)
+          query.gsub!(",#{Base::QUERY_SPACE}", ',')
+          query.gsub!(/\[.*?\]/) { |substr| substr.gsub(' ', '') }
+          query
+        end
       end
     end
   end

data/lib/sql_query_executor/query/sub_query.rb

@@ -35,7 +35,7 @@ module SqlQueryExecutor
         @children.each do |child|
           if child.respond_to?(:binding_operator) && child.binding_operator
             operator = BINDING_OPERATORS.invert[child.binding_operator]
-            hash = {operator.to_sym => [hash,child.selector]}
+            hash = {"$#{operator}" => [hash,child.selector]}
           else
             hash.merge!(child.selector)
           end
@@ -45,7 +45,7 @@ module SqlQueryExecutor
       end
 
       def to_sql
-        QueryNormalizer.clean_query(@query)
+        SqlQueryExecutor::Query::Normalizers::QueryNormalizer.clean_query(@query)
       end
 
     private

data/lib/sql_query_executor/version.rb

@@ -1,3 +1,3 @@
 module SqlQueryExecutor
-  VERSION = "0.3.2"
+  VERSION = "0.3.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sql_query_executor
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.4
 platform: ruby
 authors:
 - Caio Torres