sql_query_executor 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c42f0a76b148c57bbe10c04654bbd6380cab657b
-  data.tar.gz: c653b58ffc9a847922c2b8b1e3d88463b9b46e84
+  metadata.gz: 1ff8930d2561d2c1093c10f8027ac682025034ae
+  data.tar.gz: 9045d8b249a633ae530be73a3dc2b7ba29effac3
 SHA512:
-  metadata.gz: 48ef44419b5509ff76af6e617370350dbb7167892f0f85283d1cbd465b8349bff384319aced176870d8fbc4e42fa38ca83e8a5dc2568e2739d9170e150cd218a
-  data.tar.gz: 2000259b6d0931d496a8757c0f4619f185609f64d741a99d44d7451cc4a41f094a06bd2fe81334bf5cc73ec807ce79d1aedfc51e0fa07f15bb032f1ac5165089
+  metadata.gz: aa8d67868b67353de090839b61c5b8c847cbc4d28ec552b3b11ca85378cf49f2666002013cd7cd0a121d0f0e6d595448f699f3fe5fcfade389e9be9334a9a77c
+  data.tar.gz: 03413bc22a1e936bec0eac260f8e0ba7d39f0decce5f0442f535204b3509a3587834feb04a015622f6192b9eef28df13c76be9bbc097f38cf4f1c035608a669b

data/lib/sql_query_executor/base.rb

@@ -1,34 +1,54 @@
 require 'ostruct'
-require 'sql_query_executor/query/base'
+require 'sql_query_executor/query/query_normalizer'
 require 'sql_query_executor/query/sub_query'
 
 # Simulates a SQL where clause to filter objects from the database
 module SqlQueryExecutor #:nodoc:
   class Base #:nodoc:
-    def initialize(collection=[])
-      @collection = []
-
-      if collection.any? && collection.first.is_a?(Hash)
-        convert_collection(collection)
-      else
-        @collection = conforming_collection?(collection) ? collection : []
-      end
-    end
+    STRING_SPACE    = "$SS$"
+    QUERY_SPACE     = "$QS$"
+    TEMP_SPACE      = "$TS$"
 
-    # Recursive method that divides the query in sub queries, executes each part individually
-    # and finally relates its results as specified in the query.
-    def where(*query)
-      query = query.first if query.respond_to?(:size) && query.size == 1
+    def initialize(collection, query)
+      query = query.first if query.respond_to?(:size) && query.size == 1 && !query.is_a?(Hash)
 
       message = check_query(query)
       raise ArgumentError.new(message) if message
 
-      query = SqlQueryExecutor::Query::Base.new(query, @collection)
-      query.execute!
+      get_collection(collection)
+      query = Query::QueryNormalizer.execute(query)
+      @query = SqlQueryExecutor::Query::SubQuery.new query, @collection
+    end
+
+    def execute!
+      @query.execute!
+    end
+
+    def to_sql
+      @query.to_sql
+    end
+
+    def selector
+      @query.selector
+    end
+
+    # Recursive method that divides the query in sub queries, executes each part individually
+    # and finally relates its results as specified in the query.
+    def self.where(collection, *query)
+      self.new(collection, query).execute!
     end
 
   private
+    def get_collection(collection)
+      if collection.any? && collection.first.is_a?(Hash)
+        convert_collection(collection)
+      else
+        @collection = conforming_collection?(collection) ? collection : []
+      end
+    end
+
     def convert_collection(collection)
+      @collection = []
       collection.each do |object|
         attributes = object.is_a?(Hash) ? object : object.attributes
         register = OpenStruct.new(attributes)

data/lib/sql_query_executor/operators/base.rb

@@ -1,10 +1,12 @@
+require 'sql_query_executor/base'
+
 module SqlQueryExecutor
   module Operators
     class Base
       def initialize(query, collection)
-        @query      = sanitize_query(query)
+        @query      = SqlQueryExecutor::Query::QueryNormalizer.execute(query).gsub(SqlQueryExecutor::Base::QUERY_SPACE, ' ')
         @collection = collection
-        @array      = query.split(' ')
+        @array      = @query.split(' ')
         @operator   = @query.split(' ')[1]
         @field      = get_field
         @value      = get_value
@@ -20,7 +22,7 @@ module SqlQueryExecutor
       end
 
       def get_value
-        value = @array.last.gsub(SqlQueryExecutor::Query::Base::STRING_SPACE, ' ')
+        value = @array.last.gsub(SqlQueryExecutor::Base::STRING_SPACE, ' ')
 
         convert_value(value)
       end
@@ -32,21 +34,13 @@ module SqlQueryExecutor
         methods = {3 => "convert_date", 7 => "convert_time"}
 
         array = split(value)
-  
+
         value = (send(methods[array.size], array) || value) if methods.keys.include?(array.size)
 
         value
       end
 
     private
-      def sanitize_query(query)
-        params = query.scan(/(\(.*?\))/).flatten.compact
-
-        params.each { |param| query.gsub!(param, param.gsub(" ", "")) }
-
-        query
-      end
-
       def is_a_number?(value)
         value.to_s == value.to_i.to_s
       end

data/lib/sql_query_executor/operators/between.rb

@@ -3,7 +3,7 @@ require 'sql_query_executor/operators/base'
 module SqlQueryExecutor
   module Operators
     class Between < SqlQueryExecutor::Operators::Base
-      def execute!(result)
+      def execute!
         @collection.select do |record|
           value = convert_value(record.send(@field).to_s)
 
@@ -26,8 +26,8 @@ module SqlQueryExecutor
       def get_value
         value = []
 
-        value << convert_value(@array[2].gsub(SqlQueryExecutor::Query::Base::STRING_SPACE, ' '))
-        value << convert_value(@array[4].gsub(SqlQueryExecutor::Query::Base::STRING_SPACE, ' '))
+        value << convert_value(@array[2].gsub(SqlQueryExecutor::Base::STRING_SPACE, ' '))
+        value << convert_value(@array[4].gsub(SqlQueryExecutor::Base::STRING_SPACE, ' '))
       end
     end
   end

data/lib/sql_query_executor/operators/default.rb

@@ -17,7 +17,7 @@ module SqlQueryExecutor
         convert_operator
       end
 
-      def execute!(result)
+      def execute!
         @collection.select do |record|
           value = record.send(@field.to_s)
 
@@ -28,7 +28,7 @@ module SqlQueryExecutor
       def selector
         operator = SELECTORS[@operator]
 
-        { @field.to_sym => operator ? {operator => @value} : @value}
+        { @field => operator ? {operator => @value} : @value}
       end
 
     private

data/lib/sql_query_executor/operators/in.rb

@@ -3,7 +3,7 @@ require 'sql_query_executor/operators/base'
 module SqlQueryExecutor
   module Operators
     class In < SqlQueryExecutor::Operators::Base
-      def execute!(result)
+      def execute!
         result = @collection.select do |record|
           value = record.send(@field)
 
@@ -19,7 +19,7 @@ module SqlQueryExecutor
       def get_value
         value = super
 
-        value.gsub(SqlQueryExecutor::Query::Base::STRING_SPACE, '').split(',').map &:strip
+        value.gsub(SqlQueryExecutor::Base::STRING_SPACE, '').split(',').map{ |v| convert_value(v) }
       end
     end
   end

data/lib/sql_query_executor/operators/is.rb

@@ -8,17 +8,21 @@ module SqlQueryExecutor
         convert_operator
       end
 
-      def execute!(result)
+      def execute!
         @collection.select do |record|
           value = record.send(@field)
 
-          value.send(@operator, nil)
+          value.send(@operator, @value)
         end
       end
 
+      def selector
+        @operator == '==' ? { @field => @value } : { @field => {'$ne' => @value} }
+      end
+
     private
       def get_value
-        @array.include?('null') ? 'nil' : @array.last
+        @array.include?('null') ? nil : convert_value(@array.last)
       end
 
       def convert_operator

data/lib/sql_query_executor/query/query_normalizer.rb

@@ -4,19 +4,17 @@ module SqlQueryExecutor
   module Query
     class QueryNormalizer
       class << self
-        CONVERT_METHODS = {"String" => ["get_query", ""], "Array" => ["interpolate_query", "query.flatten"], "Hash" => ["concatenate_hash", "query"]}
+        CONVERT_METHODS = {"String" => "get_query", "Array" => "interpolate_query", "Hash" => "concatenate_hash"}
 
         def execute(query)
           query = clean_query_attribute(query)
-          array = CONVERT_METHODS[query.class.name]
+          method = CONVERT_METHODS[query.class.name]
 
-          query = sanitize(send(array.first, query))
+          query = sanitize(send(method, query))
         end
 
         def clean_query(query)
-          query = execute(query)
-
-          remove_placeholders(query)
+          remove_placeholders execute(query)
         end
 
       private
@@ -84,6 +82,7 @@ module SqlQueryExecutor
         end
 
         def remove_spaces(query)
+          query.gsub!(",#{Base::QUERY_SPACE}", ',')
           query.gsub!(/\[.*?\]/) { |substr| substr.gsub(' ', '') }
           query
         end
@@ -91,14 +90,16 @@ module SqlQueryExecutor
         # 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 = "'#{param}'".gsub("''", "'").gsub('""', '"')
+            "'#{param}'".gsub("''", "'").gsub('""', '"')
           when "Date"
-            param = "'#{param.strftime("%Y-%m-%d")}'"
+            "'#{param.strftime("%Y-%m-%d")}'"
           when "Time"
-            param = "'#{param.strftime("%Y-%m-%d %H:%M:%S %z")}'"
+            "'#{param.strftime("%Y-%m-%d %H:%M:%S %z")}'"
           else
-            param = param.to_s
+            param.to_s
           end
         end
 
@@ -109,14 +110,15 @@ module SqlQueryExecutor
 
           query.each do |key, value|
             if value.is_a?(Array)
-              if [:and, :or].include?(key)
+              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} ")
+                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(',')})"
@@ -130,11 +132,12 @@ module SqlQueryExecutor
                 value = convert_param(value.values.first)
               end
 
-              value = "#{convert_param(value)}"
-              query_array << "#{key} #{operator} #{value}"
+              value = convert_param(value)
+              query_array << (value.nil? ? "#{key} is null" : "#{key} #{operator} #{value}")
             end
           end
 
+
           query_array.join(" and ")
         end
       end

data/lib/sql_query_executor/query/sentence.rb

@@ -6,7 +6,7 @@ require 'sql_query_executor/operators/in'
 module SqlQueryExecutor
   module Query
     class Sentence
-      attr_reader :query, :operator
+      attr_reader :query
 
       OPERATORS = {
         "between" => SqlQueryExecutor::Operators::Between,
@@ -31,10 +31,11 @@ module SqlQueryExecutor
         set_operator
       end
 
-      def execute!(data)
+      # The data parameter is only declared for SubQuery compatibility purposes
+      def execute!(data=[])
         return [] unless @operator
 
-        @operator.execute!(data)
+        @operator.execute!
       end
 
       def selector

data/lib/sql_query_executor/version.rb

@@ -1,3 +1,3 @@
 module SqlQueryExecutor
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/spec/sql_query_executor/base_spec.rb

@@ -1,527 +1,91 @@
 require 'spec_helper'
 
 require 'sql_query_executor'
+require 'sql_query_executor/base'
 
-describe SqlQueryExecutor, "Base" do
-  before do
-    @data = []
-
-    @data << {id: 1, name: "US",     language: 'English'}
-    @data << {id: 2, name: "Canada", language: 'English', monarch: "The Crown of England"}
-    @data << {id: 3, name: "Mexico", language: 'Spanish'}
-    @data << {id: 4, name: "UK",     language: 'English', monarch: "The Crown of England"}
-    @data << {id: 5, name: "Brazil", founded_at: Time.parse('1500-04-22 13:34:25')}
-  end
-
-  subject { SqlQueryExecutor::Base.new(@data) }
-
-  describe "initialize" do
-    before do
-      class Model
-        attr_reader :attributes
-
-        def initialize(attributes)
-          @attributes = attributes
-        end
-
-        def id
-          @attributes[:id]
-        end
-      end
-
-      class Collection
-        def initialize(collection)
-          @collection = []
-
-          collection.each do |hash|
-            @collection << Model.new(hash)
-          end
-        end
-
-        def all
-          @collection
-        end
-      end
-    end
-
-    subject { SqlQueryExecutor::Base.new(Collection.new(@data).all) }
-
-    it 'initializes with a conforming collection' do
-      expect(subject.where(id: 1).first.attributes).to eq (@data.first)
-    end
-  end
-
+describe SqlQueryExecutor::Base do
   describe ".where" do
-    context "when invalid query is passed" do
-      it "raises an ArgumentError" do
-        query = [{name: "John"}]
-
-        expect { subject.where(query) }.to raise_error(ArgumentError, "First element from array must be a String. eg: [\"name = ?\", \"John\"]")
-      end
-    end
-
-    describe "=" do
-      context "when attribute is string" do
-        it "matches a record" do
-          record = subject.where("name = 'US'")
-          record.size.should == 1
-          record.first.id.should == 1
-          record.first.name.should == 'US'
-        end
-
-        it "doesn't match any record" do
-          record = subject.where("name = 'Argentina'")
-          record.count.should == 0
-          record.should == []
-        end
-      end
-
-      context "when attribute is integer" do
-        it "matches a record" do
-          record = subject.where("id = 1")
-          record.count.should == 1
-          record.first.id.should == 1
-          record.first.name.should == 'US'
-        end
-
-        it "doesn't match any record" do
-          record = subject.where("id = 43")
-          record.count.should == 0
-          record.should == []
-        end
-      end
-
-      context "when attribute is datetime" do
-        it "matches a record" do
-          record = subject.where("founded_at = ?", Time.parse('1500-04-22 13:34:25'))
-          record.count.should == 1
-          record.first.id.should == 5
-          record.first.name.should == 'Brazil'
-        end
-
-        it "doesn't match any record" do
-          record = subject.where("id = ?", Time.parse('1500-09-07 13:34:25'))
-          record.count.should == 0
-          record.should == []
-        end
-      end
+    let(:data) do
+      [
+        {id: 1, name: "US",     language: 'English'},
+        {id: 2, name: "Canada", language: 'English', monarch: "The Crown of England"},
+        {id: 3, name: "Mexico", language: 'Spanish'},
+        {id: 4, name: "UK",     language: 'English', monarch: "The Crown of England"},
+        {id: 5, name: "Brazil", founded_at: Time.parse('1500-04-22 13:34:25')}
+      ]
     end
 
-    describe ">" do
-      context "when attribute is a string" do
-        it "matches a record" do
-          records = subject.where("name > 'T'")
-          records.count.should == 2
-          records.first.id.should == 1
+    context 'conforming collection' do
+      before do
+        class Model
+          attr_reader :attributes
 
-          records.map! do |record|
-            record.to_h
+          def initialize(attributes)
+            @attributes = attributes
           end
 
-          records.should == [@data[0], @data[3]]
-        end
-
-        it "doesn't match any record" do
-          record = subject.where("name > 'Z'")
-          record.count.should == 0
-          record.should == []
-        end
-      end
-
-      context "when attribute is integer" do
-        it "matches a record" do
-          records = subject.where("id > 3")
-          records.count.should == 2
-          records.first.id.should == 4
-
-          records.map! do |record|
-            record.to_h
+          def id
+            @attributes[:id]
           end
-
-          records.should == [@data[3], @data[4]]
         end
 
-        it "doesn't match any record" do
-          record = subject.where("id > 5")
-          record.count.should == 0
-          record.should == []
-        end
-      end
-
-      context "when attribute is datetime" do
-        it "matches a record" do
-          record = subject.where("founded_at > ?", Time.parse('1500-04-20 13:34:25'))
-          record.count.should == 1
-          record.first.id.should == 5
-          record.first.name.should == 'Brazil'
-        end
-
-        it "doesn't match any record" do
-          record = subject.where("founded_at > ?", Time.parse('1500-04-23 13:34:25'))
-          record.count.should == 0
-          record.should == []
-        end
-      end
-    end
-
-    describe ">=" do
-      context "when attribute is a string" do
-        it "matches a record" do
-          records = subject.where("name >= 'U'")
-          records.count.should == 2
-          records.first.id.should == 1
+        class Collection
+          def initialize(collection)
+            @collection = []
 
-          records.map! do |record|
-            record.to_h
+            collection.each do |hash|
+              @collection << Model.new(hash)
+            end
           end
 
-          records.should == [@data[0], @data[3]]
-        end
-
-        it "doesn't match any record" do
-          record = subject.where("name >= 'Z'")
-          record.count.should == 0
-          record.should == []
-        end
-      end
-
-      context "when attribute is integer" do
-        it "matches a record" do
-          records = subject.where("id >= 4")
-          records.count.should == 2
-          records.first.id.should == 4
-
-          records.map! do |record|
-            record.to_h
+          def all
+            @collection
           end
-
-          records.should == [@data[3], @data[4]]
-        end
-
-        it "doesn't match any record" do
-          record = subject.where("id >= 6")
-          record.count.should == 0
-          record.should == []
         end
       end
 
-      context "when attribute is datetime" do
-        it "matches a record" do
-          record = subject.where("founded_at >= ?", Time.parse('1500-04-22 13:34:25'))
-          record.count.should == 1
-          record.first.id.should == 5
-          record.first.name.should == 'Brazil'
-        end
-
-        it "doesn't match any record" do
-          record = subject.where("founded_at >= ?", Time.parse('1500-04-23 13:34:25'))
-          record.count.should == 0
-          record.should == []
-        end
-      end
-    end
-
-    describe "<" do
-      context "when attribute is a string" do
-        it "matches a record" do
-          records = subject.where("name < 'C'")
-          records.count.should == 1
-          records.first.id.should == 5
-
-          records.map! do |record|
-            record.to_h
-          end
-
-          records.should == [@data[4]]
-        end
-
-        it "doesn't match any record" do
-          record = subject.where("name < 'B'")
-          record.count.should == 0
-          record.should == []
-        end
+      it 'initializes with a conforming collection' do
+        expect(described_class.where(Collection.new(data).all, id: 1).first.attributes).to eq (data.first)
       end
+      
+      context "when invalid query is passed" do
+        it "raises an ArgumentError" do
+          query = [{name: "John"}]
 
-      context "when attribute is integer" do
-        it "matches a record" do
-          records = subject.where("id < 3")
-          records.count.should == 2
-          records.first.id.should == 1
-
-          records.map! do |record|
-            record.to_h
-          end
-
-          records.should == [@data[0], @data[1]]
-        end
-
-        it "doesn't match any record" do
-          record = subject.where("id < 1")
-          record.count.should == 0
-          record.should == []
-        end
-      end
-
-      context "when attribute is datetime" do
-        it "matches a record" do
-          record = subject.where("founded_at < ?", Time.parse('1500-04-22 13:34:26'))
-          record.count.should == 1
-          record.first.id.should == 5
-          record.first.name.should == 'Brazil'
-        end
-
-        it "doesn't match any record" do
-          record = subject.where("founded_at < ?", Time.parse('1500-04-22 13:34:25'))
-          record.count.should == 0
-          record.should == []
+          expect { described_class.where(Collection.new(data).all, query) }.to raise_error(ArgumentError, "First element from array must be a String. eg: [\"name = ?\", \"John\"]")
         end
       end
     end
 
-    describe "<=" do
-      context "when attribute is a string" do
-        it "matches a record" do
-          records = subject.where("name <= 'Brb'")
-          records.count.should == 1
-          records.first.id.should == 5
-
-          records.map! do |record|
-            record.to_h
-          end
-
-          records.should == [@data[4]]
-        end
-
-        it "doesn't match any record" do
-          record = subject.where("name <= 'A'")
-          record.count.should == 0
-          record.should == []
-        end
-      end
-
-      context "when attribute is integer" do
-        it "matches a record" do
-          records = subject.where("id <= 2")
-          records.count.should == 2
-          records.first.id.should == 1
-
-          records.map! do |record|
-            record.to_h
-          end
-
-          records.should == [@data[0], @data[1]]
-        end
-
-        it "doesn't match any record" do
-          record = subject.where("id <= 0")
-          record.count.should == 0
-          record.should == []
-        end
-      end
-
-      context "when attribute is datetime" do
-        it "matches a record" do
-          record = subject.where("founded_at <= ?", Time.parse('1500-04-22 13:34:25'))
-          record.count.should == 1
-          record.first.id.should == 5
-          record.first.name.should == 'Brazil'
-        end
-
-        it "doesn't match any record" do
-          record = subject.where("founded_at <= ?", Time.parse('1500-04-22 13:34:24'))
-          record.count.should == 0
-          record.should == []
-        end
-      end
-    end
-
-    describe "between" do
-      context "when attribute is a string" do
-        it "matches a record" do
-          records = subject.where("name between 'A' and 'C'")
-          records.count.should == 1
-          records.first.id.should == 5
-
-          records.map! do |record|
-            record.to_h
-          end
-
-          records.should == [@data[4]]
-        end
-
-        it "doesn't match any record" do
-          record = subject.where("name between 'K' and 'M'")
-          record.count.should == 0
-          record.should == []
-        end
-      end
-
-      context "when attribute is integer" do
-        it "matches a record" do
-          records = subject.where("id between 1 and 2")
-          records.count.should == 2
-          records.first.id.should == 1
-
-          records.map! do |record|
-            record.to_h
-          end
-
-          records.should == [@data[0], @data[1]]
-        end
-
-        it "doesn't match any record" do
-          record = subject.where("id between 6 and 10")
-          record.count.should == 0
-          record.should == []
-        end
-      end
-
-      context "when attribute is datetime" do
-        it "matches a record" do
-          record = subject.where("founded_at between ? and ?", Time.parse('1500-04-22 13:34:24'), Time.parse('1500-04-22 13:34:26'))
-          record.count.should == 1
-          record.first.id.should == 5
-          record.first.name.should == 'Brazil'
-        end
-
-        it "doesn't match any record" do
-          record = subject.where("founded_at between ? and ?", Time.parse('1500-04-22 13:34:26'), Time.parse('1500-09-22 13:34:25'))
-          record.count.should == 0
-          record.should == []
-        end
-      end
-    end
-
-    describe "is" do
-      it "attribute is condition" do
-        records = subject.where("founded_at is null")
-        records.count.should == 4
-        records.first.id.should == 1
-
-        records.map! do |record|
-          record.to_h
-        end
-
-        records.should == [@data[0], @data[1], @data[2], @data[3]]
+    context 'not conforming collection' do
+      it 'initializes with a conforming collection' do
+        expect(described_class.where(data, id: 1)).to eq([OpenStruct.new(data.first)])
       end
+      
+      context "when invalid query is passed" do
+        it "raises an ArgumentError" do
+          query = [{name: "John"}]
 
-      it "attribute is not condition" do
-        id = @data.last[:id]
-        records = subject.where("founded_at is not null")
-        records.count.should == 1
-        records.first.id.should == id
-
-        records.map! do |record|
-          record.to_h
+          expect { described_class.where(data, query) }.to raise_error(ArgumentError, "First element from array must be a String. eg: [\"name = ?\", \"John\"]")
         end
-
-        records.should == [@data[id-1]]
       end
     end
 
-    describe "and" do
-      it "attribute and condition" do
-        records = subject.where("language = 'English' and monarch = 'The Crown of England'")
-        records.count.should == 2
-        records.first.id.should == 2
-
-        records.map! do |record|
-          record.to_h
-        end
-
-        records.should == [@data[1], @data[3]]
-      end
-
-      it "integer attribute and condition" do
-        records = subject.where("id = 2 and language = 'English'")
-        records.count.should == 1
-        records.first.id.should == 2
+    context 'selector' do
+      let(:query)    { 'id > 3' }
+      let(:selector) { {'id' => {'$gt' => 3}} }
 
-        records.map! do |record|
-          record.to_h
-        end
-
-        records.should == [@data[1]]
+      it 'converts query' do
+        expect(described_class.new([], query).selector).to eq selector
       end
     end
 
-    describe "or" do
-      it "attribute or condition" do
-        records = subject.where("language = 'English' or language = 'Spanish'")
-        records.count.should == 4
-        records.first.id.should == 1
-
-        records.map! do |record|
-          record.to_h
-        end
-
-        records.should == [@data[0], @data[1], @data[2], @data[3]]
-      end
-
-      context "nested queries" do
-        it "respects priority" do
-          records = subject.where("(language = 'English' and name = 'US') or (language is null)")
-          records.count.should == 2
-          records.first.id.should == 1
-
-          records.map! do |record|
-            record.to_h
-          end
-
-          records.should == [@data[0], @data[4]]
-        end
-
-        it "respects priority" do
-          records = subject.where("(language is null) or (language = 'English' and name = 'US')")
-          records.count.should == 2
-          records.first.id.should == 1
-
-          records.map! do |record|
-            record.to_h
-          end
-
-          records.should == [@data[0], @data[4]]
-        end
-      end
-    end
-
-    describe "in" do
-      it "attribute in condition" do
-        records = subject.where("language in ('English', 'Spanish')")
-        records.count.should == 4
-        records.first.id.should == 1
-
-        records.map! do |record|
-          record.to_h
-        end
-
-        records.should == [@data[0], @data[1], @data[2], @data[3]]
-      end
-
-      xit "attribute not in condition" do
-        records = subject.where("language not in ('English', 'Spanish')")
-        records.count.should == 1
-        records.first.id.should == 5
-
-        records.map! do |record|
-          record.to_h
-        end
-
-        records.should == [@data[4]]
-      end
-    end
-
-    describe "not" do
-      xit "attribute not condition" do
-        records = subject.where("not language = 'English'")
-        records.count.should == 1
-        records.first.id.should == 5
-
-        records.map! do |record|
-          record.to_h
-        end
+    context 'to_sql' do
+      let(:query)    { "name = 'Brazil'" }
+      let(:selector) { {name: 'Brazil'} }
 
-        records.should == [@data[4]]
+      it 'converts selector' do
+        expect(described_class.new([], selector).to_sql).to eq query
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sql_query_executor
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Caio Torres
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-05 00:00:00.000000000 Z
+date: 2014-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -68,7 +68,6 @@ 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/base.rb
 - lib/sql_query_executor/query/query_normalizer.rb
 - lib/sql_query_executor/query/sentence.rb
 - lib/sql_query_executor/query/sub_query.rb

data/lib/sql_query_executor/query/base.rb

@@ -1,28 +0,0 @@
-require 'sql_query_executor/query/query_normalizer'
-
-module SqlQueryExecutor
-  module Query
-    class Base
-      STRING_SPACE    = "$SS$"
-      QUERY_SPACE     = "$QS$"
-      TEMP_SPACE      = "$TS$"
-
-      def initialize(query, collection)
-        query = QueryNormalizer.execute(query)
-        @query = SqlQueryExecutor::Query::SubQuery.new query, collection
-      end
-
-      def execute!
-        @query.execute!
-      end
-
-      def to_sql
-        @query.to_sql
-      end
-
-      def selector
-        @query.selector
-      end
-    end
-  end
-end