dm-parse 0.3.6 → 0.3.7

data/VERSION

@@ -1 +1 @@
-0.3.6
+0.3.7

data/dm-parse.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "dm-parse"
-  s.version = "0.3.6"
+  s.version = "0.3.7"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Zhi-Qiang Lei"]
-  s.date = "2012-07-03"
+  s.date = "2012-07-04"
   s.description = "An extension to make DataMapper working on Parse.com"
   s.email = "zhiqiang.lei@gmail.com"
   s.extra_rdoc_files = [

data/lib/adapters/parse/query.rb

@@ -7,7 +7,7 @@ module DataMapper
           @value = value
         end
 
-        def build
+        def as_json
           { key_name => @value }
         end
 
@@ -17,7 +17,7 @@ module DataMapper
       end
 
       class Eql < Comparison
-        def build
+        def as_json
           @value
         end
       end
@@ -58,57 +58,8 @@ module DataMapper
           result.join
         end
 
-        def build
-          {key_name => @value.source}.tap { |value| value["$options"] = options if options.present? }
-        end
-      end
-
-      class And
-        def initialize
-          @conditions = Mash.new
-        end
-
-        def add(field, comparison)
-          @conditions[field] ||= []
-          @conditions[field] << comparison
-          self
-        end
-
-        def combine(comparisons)
-          groups = comparisons.group_by { |comparison| comparison.is_a? Eql }
-          equals = groups[true]
-          others = groups[false]
-
-          if equals.present? && others.present?
-            raise "Parse Query: cannot combine Eql with others"
-          elsif equals.present?
-            raise "can only use one EqualToComparison for a field" unless equals.size == 1
-            equals.first.build
-          elsif others.present?
-            others.inject({}) do |result, comparison|
-              result.merge! comparison.build
-            end
-          end
-        end
-
-        def build
-          @conditions.inject({}) do |result, (field, comparisons)|
-            result.merge! field => combine(comparisons)
-          end
-        end
-      end
-
-      class Or
-        def initialize
-          @queries = []
-        end
-
-        def add(query)
-          @queries << query
-        end
-
-        def build
-          {"$or" => @queries.map { |query| query.build } }
+        def as_json
+          { key_name => @value.source }.tap { |value| value["$options"] = options if options.present? }
         end
       end
 

data/lib/adapters/parse_adapter.rb

@@ -163,82 +163,112 @@ module DataMapper
         conditions  = query.conditions
         return nil if conditions.blank?
 
-        case conditions
+        result = {}
+        translate(conditions, result)
+        finalize result
+      end
+
+      def translate(condition, result)
+        case condition
+        when RegexpComparison
+          translate_for(result, condition, Regex)
+        when EqualToComparison
+          translate_for(result, condition, Eql)
+        when GreaterThanComparison
+          translate_for(result, condition, Gt)
+        when GreaterThanOrEqualToComparison
+          translate_for(result, condition, Gte)
+        when LessThanComparison
+          translate_for(result, condition, Lt)
+        when LessThanOrEqualToComparison
+          translate_for(result, condition, Lte)
+        when InclusionComparison
+          translate_for(result, condition, In)
         when NotOperation
-          parse_query = Parse::Conditions::And.new
-          feed_reversely(parse_query, conditions)
+          condition.each { |c| translate_reversely c, result }
         when AndOperation
-          parse_query = Parse::Conditions::And.new
-          feed_directly(parse_query, conditions)
+          condition.each { |c| translate c, result }
         when OrOperation
-          parse_query = Parse::Conditions::Or.new
-          feed_or(parse_query, conditions)
+          result["$or"] ||= []
+          result["$or"] = result["$or"] + condition.map do |c|
+            r = {}
+            translate c, r
+            r
+          end
+        else
+          raise NotImplementedError
         end
+      end
 
-        parse_query.build
+      def translate_reversely(condition, result)
+        case condition
+        when EqualToComparison
+          translate_for(result, condition, Ne)
+        when GreaterThanComparison
+          translate_for(result, condition, Lte)
+        when GreaterThanOrEqualToComparison
+          translate_for(result, condition, Lt)
+        when LessThanComparison
+          translate_for(result, condition, Gte)
+        when LessThanOrEqualToComparison
+          translate_for(result, condition, Gt)
+        when InclusionComparison
+          translate_for(result, condition, Nin)
+        when NotOperation
+          condition.each { |c| translate c, result }
+        when AndOperation
+          condition.each { |c| translate_reversely c, result }
+        else
+          raise NotImplementedError
+        end
       end
 
-      def feed_for(parse_query, condition, comparison_class)
+      def translate_for(result, condition, comparison_class)
         subject = condition.subject
+
         case subject
         when DataMapper::Property
-          comparison = comparison_class.new condition.value
-          parse_query.add subject.field, comparison
+          field = subject.field
+          result[field] ||= []
+          result[field] << comparison_class.new(condition.value)
         when DataMapper::Associations::OneToMany::Relationship
           child_key = condition.subject.child_key.first
-          parse_query.add "objectId", comparison_class.new(condition.value.map { |resource| resource.send child_key.name })
+          result["objectId"] ||= []
+          result["objectId"] << comparison_class.new(condition.value.map { |resource| resource.send child_key.name })
         when DataMapper::Associations::ManyToOne::Relationship
           child_key = subject.child_key.first
-          parse_query.add child_key.field, comparison_class.new(condition.foreign_key_mapping.value)
+          field     = child_key.field
+          result[field] ||= []
+          result[field] << comparison_class.new(condition.foreign_key_mapping.value)
         else
           raise NotImplementedError, "Condition: #{condition}"
         end
       end
 
-      def feed_reversely(parse_query, conditions)
-        conditions.each do |condition|
-          case condition
-          when EqualToComparison              then feed_for(parse_query, condition, Ne)
-          when GreaterThanComparison          then feed_for(parse_query, condition, Lte)
-          when GreaterThanOrEqualToComparison then feed_for(parse_query, condition, Lt)
-          when LessThanComparison             then feed_for(parse_query, condition, Gte)
-          when LessThanOrEqualToComparison    then feed_for(parse_query, condition, Gt)
-          when NotOperation                   then feed_directly(parse_query, condition)
-          when AndOperation                   then feed_reversely(parse_query, condition)
-          when InclusionComparison            then feed_for(parse_query, condition, Nin)
+      def finalize(queries)
+        queries.inject({}) do |result, (field, comparisons)|
+          if field == "$or"
+            result.merge! field => comparisons.map { |c| finalize c }
           else
-            raise NotImplementedError
+            result.merge! field => combine(comparisons)
           end
         end
       end
 
-      def feed_directly(parse_query, conditions)
-        conditions.each do |condition|
-          feed_with_condition parse_query, condition
-        end
-      end
-
-      def feed_or(queries, conditions)
-        conditions.each do |condition|
-          parse_query = Parse::Conditions::And.new
-          feed_with_condition parse_query, condition
-          queries.add parse_query
-        end
-      end
-
-      def feed_with_condition(parse_query, condition)
-        case condition
-        when RegexpComparison               then feed_for(parse_query, condition, Regex)
-        when EqualToComparison              then feed_for(parse_query, condition, Eql)
-        when GreaterThanComparison          then feed_for(parse_query, condition, Gt)
-        when GreaterThanOrEqualToComparison then feed_for(parse_query, condition, Gte)
-        when LessThanComparison             then feed_for(parse_query, condition, Lt)
-        when LessThanOrEqualToComparison    then feed_for(parse_query, condition, Lte)
-        when InclusionComparison            then feed_for(parse_query, condition, In)
-        when NotOperation                   then feed_reversely(parse_query, condition)
-        when AndOperation                   then feed_directly(parse_query, condition)
-        else
-          raise NotImplementedError
+      def combine(comparisons)
+        groups = comparisons.group_by { |comparison| comparison.is_a? Eql }
+        equals = groups[true]
+        others = groups[false]
+
+        if equals.present? && others.present?
+          raise "Parse Query: cannot combine Eql with others"
+        elsif equals.present?
+          raise "can only use one EqualToComparison for a field" unless equals.size == 1
+          equals.first.as_json
+        elsif others.present?
+          others.inject({}) do |result, comparison|
+            result.merge! comparison.as_json
+          end
         end
       end
 

data/spec/parse_adapter_spec.rb

@@ -61,6 +61,11 @@ describe DataMapper::Adapters::ParseAdapter do
     context "when query has :or operation" do
       let(:query) { (model.all(:rank => 3) + model.all(:rank => 4) + model.all(:rank => 5)).query }
       it { should eq("$or" => [{"rank" => 3}, {"rank" => 4}, {"rank" => 5}]) }
+
+      context "in :and operation" do
+        let(:query) { (model.all(:title => "x") & (model.all(:rank => 3) + model.all(:rank => 4))).query }
+        it { should eq("title" => "x", "$or" => [{"rank" => 3}, {"rank" => 4}]) }
+      end
     end
 
     context "when query has union operator" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dm-parse
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.3.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-03 00:00:00.000000000 Z
+date: 2012-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dm-core
@@ -242,7 +242,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4240417428092590610
+      hash: -1860376599775651579
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: