sql_query_executor 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3c2510b202eeac4b6e79770f6395b636d90ca8e2
-  data.tar.gz: be4eb8d91ec1a237374a0d9ffb795efb715f3392
+  metadata.gz: 69f41682d9033acdb640a38d097d9f99eb13cabd
+  data.tar.gz: 3a0b636c3771ca0fbece8a6a9cfef45df2abca80
 SHA512:
-  metadata.gz: ff562466f8d562bf0ef3d14b5d788f9d9faa31f1dbce72b8e48d214cbfa2aea5b3f0840a0b4c88c2d95e19b87907298e33f4f154bdfb0753e0ddec3772e95a56
-  data.tar.gz: 8ee24c50076d39fdec78b8187d19b944ee024ac0efd136f6d1cb6d5b1bc80935e7449e1c604df2358c4198193ab1bfea73f46b5433cd9c4a6196f201426708b8
+  metadata.gz: 535d00055be485560c0c2a41e4dab3ddf16cb4d462f5656cdc40f84a65838e6a003c37076fb5d68f0c58488bd2908b83c9ac783327644ebb1e03c3c0410e1299
+  data.tar.gz: c353d5a6f9b4e55cfb2c0a5fd868e10f205539a6d5a6fd0f400eb3d7e2d731b9b595bea31b6423c88386221fe92de36dba58661f28de9e6a86e2f4e85fba5a00

data/lib/sql_query_executor/base.rb

@@ -1,5 +1,5 @@
 require 'ostruct'
-require 'sql_query_executor/query/query_normalizer'
+require 'sql_query_executor/query/normalizers/query_normalizer'
 require 'sql_query_executor/query/sub_query'
 
 # Simulates a SQL where clause to filter objects from the database

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

@@ -0,0 +1,24 @@
+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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'sql_query_executor'
+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)
+          end
+        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 = []
+
+          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(',')})"
+        end
+      end
+
+      def self.normal_hash(key, value)
+        operator = '='
+
+        if value.is_a?(Hash)
+          operator = OPERATORS[value.keys.first] || operator
+
+          value = convert_param(value.values.first)
+        end
+
+        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

@@ -0,0 +1,96 @@
+require 'sql_query_executor'
+require 'sql_query_executor/query/normalizers/base_normalizer'
+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"}
+
+      def self.execute(query)
+        query = clean_query_attribute(query)
+        method = CONVERT_METHODS[query.class.name]
+
+        query = sanitize(send(method, query))
+      end
+
+      def self.clean_query(query)
+        remove_placeholders execute(query).gsub('!=', '<>')
+      end
+
+    private
+      def self.convert_hash(query)
+        OriginNormalizer.execute(query)
+      end
+
+      def self.remove_placeholders(query)
+        query.gsub(Base::QUERY_SPACE, ' ').gsub(Base::STRING_SPACE, ' ').gsub(Base::TEMP_SPACE, ' ')
+      end
+
+      def self.clean_query_attribute(query)
+        return query unless query.is_a?(Array)
+
+        query = query.flatten
+
+        (query.size == 1 ? query.first : query)
+      end
+
+      def self.get_query(query)
+        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)
+
+        query = args.first
+        param = args.delete_at(1)
+
+        param = convert_param(param)
+
+        args[0] = query.sub("?", param.is_a?(Numeric) ? param : "#{param}")
+
+        interpolate_query(args)
+      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)
+
+        remove_spaces(prepare_query(new_query))
+      end
+
+      def self.replace_on_query(query, regexp, pattern, replacement)
+        new_query = query ? query.dup : query
+
+        params = new_query.scan(regexp).flatten.compact
+
+        params.each do |param|
+          new_param = param.dup
+
+          new_param = new_param.gsub(pattern, replacement)
+
+          new_query = new_query.gsub(param, new_param)
+        end
+
+        new_query
+      end
+
+      def self.prepare_query(query)
+        SubQuery::BINDING_OPERATORS.keys.each do |operator|
+          query.gsub!(" #{operator} ", "#{Base::TEMP_SPACE}#{operator}#{Base::QUERY_SPACE}")
+        end
+
+        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/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sql_query_executor
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Caio Torres
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-10 00:00:00.000000000 Z
+date: 2014-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -68,7 +68,9 @@ files:
 - lib/sql_query_executor/operators/default.rb
 - lib/sql_query_executor/operators/in.rb
 - lib/sql_query_executor/operators/is.rb
-- lib/sql_query_executor/query/query_normalizer.rb
+- lib/sql_query_executor/query/normalizers/base_normalizer.rb
+- lib/sql_query_executor/query/normalizers/origin_normalizer.rb
+- lib/sql_query_executor/query/normalizers/query_normalizer.rb
 - lib/sql_query_executor/query/sentence.rb
 - lib/sql_query_executor/query/sub_query.rb
 - lib/sql_query_executor/version.rb

data/lib/sql_query_executor/query/query_normalizer.rb

@@ -1,146 +0,0 @@
-require 'sql_query_executor'
-
-module SqlQueryExecutor
-  module Query
-    class QueryNormalizer
-      class << self
-        CONVERT_METHODS = {"String" => "get_query", "Array" => "interpolate_query", "Hash" => "concatenate_hash"}
-
-        def execute(query)
-          query = clean_query_attribute(query)
-          method = CONVERT_METHODS[query.class.name]
-
-          query = sanitize(send(method, query))
-        end
-
-        def clean_query(query)
-          remove_placeholders execute(query)
-        end
-
-      private
-        def remove_placeholders(query)
-          query.gsub(Base::QUERY_SPACE, ' ').gsub(Base::STRING_SPACE, ' ').gsub(Base::TEMP_SPACE, ' ')
-        end
-
-        def clean_query_attribute(query)
-          return query unless query.is_a?(Array)
-
-          query = query.flatten
-
-          query.size == 1 ? query.first : query
-        end
-
-        def get_query(query)
-          query
-        end
-
-        # Prepares query by replacing all ? by it's real values in #args
-        def interpolate_query(args)
-          args.flatten!
-          return args.first if args.size == 1 && args.first.is_a?(String)
-
-          query = args.first
-          param = args.delete_at(1)
-
-          param = convert_param(param)
-
-          args[0] = query.sub("?", param.is_a?(Numeric) ? param : "#{param}")
-
-          interpolate_query(args)
-        end
-
-        # Removes all accents and other non default characters
-        def sanitize(query)
-          new_query = replace_on_query(query, /(["|'].*?["|'])/, " ", Base::STRING_SPACE)
-          new_query = replace_on_query(new_query, /(\(.*?\))/, " ", Base::QUERY_SPACE)
-
-          remove_spaces(prepare_query(new_query))
-        end
-
-        def replace_on_query(query, regexp, pattern, replacement)
-          new_query = query ? query.dup : query
-
-          params = new_query.scan(regexp).flatten.compact
-
-          params.each do |param|
-            new_param = param.dup
-
-            new_param = new_param.gsub(pattern, replacement)
-
-            new_query = new_query.gsub(param, new_param)
-          end
-
-          new_query
-        end
-
-        def prepare_query(query)
-          SubQuery::BINDING_OPERATORS.keys.each do |operator|
-            query.gsub!(" #{operator} ", "#{Base::TEMP_SPACE}#{operator}#{Base::QUERY_SPACE}")
-          end
-
-          query.gsub(" ", Base::QUERY_SPACE).gsub(Base::TEMP_SPACE, " ")
-        end
-
-        def remove_spaces(query)
-          query.gsub!(",#{Base::QUERY_SPACE}", ',')
-          query.gsub!(/\[.*?\]/) { |substr| substr.gsub(' ', '') }
-          query
-        end
-
-        # Returns converted #param based on its Class, so it can be used on the query
-        def 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 concatenate_hash(query)
-          return "" unless query.is_a?(Hash)
-          query_array = []
-          operators   = {"$gt" => '>', "$lt" => '<', "$gte" => '>=', "$lte" => '<=', "$ne" => '!=', "$in" => 'in'}
-
-          query.each do |key, value|
-            if value.is_a?(Array)
-              if ['$and', '$or'].include?(key)
-                key = key.gsub('$', '')
-                queries = []
-
-                value.each do |hash|
-                  queries << concatenate_hash(hash)
-                end
-
-                query_array << "(#{queries.join(" #{key.to_s} ")})"
-              else
-                value = value.first.is_a?(Numeric) ? value : value.map{ |v| "'#{v}'" }
-                query_array << "#{key} in (#{value.join(',')})"
-              end
-            else
-              operator = '='
-
-              if value.is_a?(Hash)
-                operator = operators[value.keys.first] || operator
-
-                value = convert_param(value.values.first)
-              end
-
-              value = convert_param(value)
-              query_array << (value.nil? ? "#{key} is null" : "#{key} #{operator} #{value}")
-            end
-          end
-
-
-          query_array.join(" and ")
-        end
-      end
-    end
-  end
-end