mongo_ql 0.0.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77a5766acd5932125249f1d647015d875df49441a91b96ac6c4391dee41ab00e
-  data.tar.gz: 4f2706c876c0b933502f5b4a3c20196dda0de92765567cdb6bb5d5f3875ad577
+  metadata.gz: e1f6676de369add0c89989cb95013bd170cc5925959f50b74ee1a7824e148b30
+  data.tar.gz: 0cd46af4aa9fa2b9a98e10e6ba7532c3aef216e3ca2d3af983b739db2fec2237
 SHA512:
-  metadata.gz: 7ad974ec17e7561e368296f6de9088c5966fa0a208cbf2f1db84df85bb3b8d8a4aed917e9549cf2bd02f2470bd3b20d10959ab05dd8c73ba3a7c8f5ab50ad548
-  data.tar.gz: d37ebf20e12bb1d92c3875a122b7c9e5c88230e1903dec148faafa59fec48257d5dfba76d3377c2b60c43d02f850e6d2823d31271f7beb2b22769ccad7b9f998
+  metadata.gz: cc76501d7a5e6e1a13a58fd4164de221f5038afd7006aa7cd8b7b1ec2b4792d278e2797b2d4d0daa117779dd63b4bf34a8c7d5c8b9d110d0ec1c8f3bedde5fd2
+  data.tar.gz: 2ec8a62fd293bcd9fc8d266424f18a3206db5be9a8e16ebcb4eb2d9e2679bfbab39e54fd64287440f6235463989a5bae220976dad4ee615b89c5b86d8b29ebb7

data/.vscode/launch.json

@@ -0,0 +1,16 @@
+{
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Listen for rdebug-ide",
+      "type": "Ruby",
+      "request": "attach",
+      "remoteHost": "127.0.0.1",
+      "remotePort": "1234",
+      "remoteWorkspaceRoot": "${workspaceRoot}"
+    }
+  ]
+}

data/README.md

@@ -1 +1,82 @@
-# mongo_ql
+
+# Query DSL
+```ruby
+Order.where { tax != 0 }                          
+#=> Order.where(tax: { "$ne": 0 })
+Order.where { total >= 100 }                      
+#=> Order.where(total: { "$gte": 100 })
+Order.where { (total >= 100) & (total_tax < 15) } 
+#=> Order.where({ "$and": [{ total: { "$gte": 100 }}, { total_tax: { "$lt": 15 }}]})
+Order.where { tax > (shipping / 2) }              
+#=> Order.where(tax: { "$gt": { "$divide": [ "$shipping", 2]}})
+Order.where { total  >= If(currency == "CAD", 100, 80) }
+#=> Order.where(total: { "$cond": { if: { "$eq": ["$currency", "CAD"]}, then: 100, else: 80 }})
+```
+
+# Aggregation Pipeline DSL
+```ruby
+Order.all.mongo_ql do
+  join    Customer,
+          on: customer_id == _id.to_id, 
+          as: customers
+
+  join    Shipping, :as => shippings do |doc|
+    match  order_id == doc._id, 
+           status   == :shipped
+  end
+
+  match   province == "ON"
+  
+  project _id, 
+          total, 
+          customer  => customers.name,
+          tax       => total * tax_rate
+
+  group   customer, 
+          total     => total.sum,
+          total_tax => tax.sum * 5
+
+  sort_by age.desc
+end
+
+# The above aggregation is equivalent to the following mognodb pipeline
+Order.collection.pipeline([
+  { "$lookup":  {
+    from:         "customers",
+    localField:   "$customer_id",
+    foreignField: "$_id",
+    as:           "customers"
+  }},
+  { "$unwind":  {
+    path:         "customers"
+  }},
+  { "$lookup":  {
+    from:         "shippings",
+    as:           "shippings",
+    let:          { doc_id: "$_id" },
+    pipeline:     [{
+      "$match": {
+        order_id: { "$eq": "$$dock_id" },
+        status: :shipped  
+      }
+    }]
+  }},
+  { "$unwind":  {
+    path:         "customers"
+  }},
+  { "$match":   {
+    province:     { "$eq": "ON" }
+  }},
+  { "$project": {
+    _id:          1,
+    total:        1,
+    customer:     "$customers.name",
+    tax:          { "$multiply": ["$total", "$tax_rate"] }
+  }},
+  { "$group":   {
+    _id:          "$customer",
+    total:        { "$sum": "$total" },
+    total_tax:    { "$multiply": [{ "$sum": "$tax" }, 5] }
+  }}
+])
+```

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/test_*.rb']
+end
+
+task :default => :test

data/debug.sh

@@ -0,0 +1,2 @@
+
+DISABLE_SPRING=1 rdebug-ide --host 0.0.0.0 --port 1234 --dispatcher-port 1234 -- bin/console

data/design_specs.md

@@ -1,26 +1,12 @@
 
-# Query DSL
-```ruby
-Order.where { tax != 0 }                          
-#=> Order.where(tax: { "$ne": 0 })
-Order.where { total >= 100 }                      
-#=> Order.where(total: { "$gte": 100 })
-Order.where { (total >= 100) & (total_tax < 15) } 
-#=> Order.where({ "$and": [{ total: { "$gte": 100 }}, { total_tax: { "$lt": 15 }}]})
-Order.where { tax > (shipping / 2) }              
-#=> Order.where(tax: { "$gt": { "$divide": [ "$shipping", 2]}})
-Order.where { total  >= If(currency == "CAD", 100, 80) }
-#=> Order.where(total: { "$cond": { if: { "$eq": ["$currency", "CAD"]}, then: 100, else: 80 }})
-```
-
 # Aggregation Pipeline DSL
 ```ruby
-Order.all.mongo_ql do
-  join    Customer,
+MongoQL.compose do
+  join    customers,
           on: customer_id == _id.to_id, 
           as: customers
 
-  join    Shipping, :as => shippings do
+  join    shippings, :as => shippings do |doc|
     match  order_id == doc._id, 
            status   == :shipped
   end
@@ -28,58 +14,80 @@ Order.all.mongo_ql do
   match   province == "ON"
   
   project :_id, 
-          :total, 
-          :customer  => customers.name,
-          :tax       => total * tax_rate
+          total, 
+          customer  => customers.name,
+          tax       => total * tax_rate
 
   group   customer, 
-          :total     => total.sum,
-          :total_tax => tax.sum * 5
+          total     => total.sum,
+          total_tax => tax.sum * 5
 
   sort_by age.desc
-
-  page 1
-  per  10
 end
+```
 
 # The above aggregation is equivalent to the following mognodb pipeline
-Order.collection.pipeline([
-  { "$lookup":  {
-    from:         "customers",
-    localField:   "$customer_id",
-    foreignField: "$_id",
-    as:           "customers"
-  }},
-  { "$unwind":  {
-    path:         "customers"
-  }},
-  { "$lookup":  {
-    from:         "shippings",
-    as:           "shippings",
-    let:          { doc_id: "$_id" },
-    pipeline:     [{
+```json
+[{
+  "$lookup": {
+    "from": "customers",
+    "as": "customers",
+    "localField": "customer_id",
+    "foreignField": {
+      "$toString": {
+        "$toObjectId": "$_id"
+      }
+    }
+  }
+}, {
+  "$lookup": {
+    "from": "shippings",
+    "as": "shippings",
+    "pipeline": [{
       "$match": {
-        order_id: { "$eq": "$$dock_id" },
-        status: :shipped  
+        "$expr": {
+          "$and": [{
+            "$eq": ["$order_id", "$$var__id"]
+          }, {
+            "$eq": ["$status", "shipped"]
+          }]
+        }
       }
-    }]
-  }},
-  { "$unwind":  {
-    path:         "customers"
-  }},
-  { "$match":   {
-    province:     { "$eq": "ON" }
-  }},
-  { "$project": {
-    _id:          1,
-    total:        1,
-    customer:     "$customers.name",
-    tax:          { "$multiply": ["$total", "$tax_rate"] }
-  }},
-  { "$group":   {
-    _id:          "$customer",
-    total:        { "$sum": "$total" },
-    total_tax:    { "$multiply": [{ "$sum": "$tax" }, 5] }
-  }}
-])
+    }],
+    "let": {
+      "var__id": "$_id"
+    }
+  }
+}, {
+  "$match": {
+    "$expr": {
+      "$eq": ["$province", "ON"]
+    }
+  }
+}, {
+  "$project": {
+    "_id": 1,
+    "total": 1,
+    "customer": "customers",
+    "tax": {
+      "$multiply": ["$total", "$tax_rate"]
+    }
+  }
+}, {
+  "$group": {
+    "_id": "$customer",
+    "total": {
+      "$sum": "$total"
+    },
+    "total_tax": {
+      "$multiply": [{
+        "$sum": "$tax"
+      }, 5]
+    }
+  }
+}, {
+  "$sort": {
+    "age.desc": 1
+  }
+}]
 ```

data/lib/mongo_ql/collection_operators.rb

@@ -22,43 +22,47 @@ module MongoQL
     end
 
     def filter(&block)
+      evaled_cond = block.call(Expression::FieldNode.new("$item"))
       Expression::MethodCall.new "$filter", self, ast_template: -> (target, **_args) {
         {
           "input" => target,
           "as"    => "item",
-          "cond"  => block.call(Expression::FieldNode.new("$item")).to_ast
+          "cond"  => evaled_cond
         }
       }
     end
 
     def map(&block)
+      evaled_in = block.call(Expression::FieldNode.new("$item"))
       Expression::MethodCall.new "$map", self, ast_template: -> (target, **_args) {
         {
           "input" => target,
           "as"    => "item",
-          "in"    => block.call(Expression::FieldNode.new("$item")).to_ast
+          "in"    => evaled_in
         }
       }
     end
 
     def reduce(initial_value, &block)
+      evaled_in = to_expression(block.call(Expression::FieldNode.new("$value"), Expression::FieldNode.new("$this")))
       Expression::MethodCall.new "$reduce", self, ast_template: -> (target, **_args) {
         {
           "input"        => target,
-          "initialValue" => to_expression(initial_value).to_ast,
-          "in"           => to_expression(block.call(Expression::FieldNode.new("$value"), Expression::FieldNode.new("$this"))).to_ast
+          "initialValue" => to_expression(initial_value),
+          "in"           => evaled_in
         }
       }
     end
 
     def contains(ele)
       Expression::MethodCall.new "$in", self, ast_template: -> (target, **_args) {
-        [to_expression(ele).to_ast, target]
+        [to_expression(ele), target]
       }
     end
     alias_method :includes, :contains
     alias_method :include,  :contains
     alias_method :include?, :contains
+    alias_method :includes?, :contains
 
   end
 end

data/lib/mongo_ql/expression/binary.rb

@@ -11,7 +11,7 @@ module MongoQL
     end
 
     def to_ast
-      { operator => [left_node.to_ast, right_node.to_ast] }
+      { operator => [left_node, right_node] }
     end
   end
 end

data/lib/mongo_ql/expression/method_call.rb

@@ -5,17 +5,17 @@ module MongoQL
     attr_accessor :method, :target, :ast_template, :args
 
     def initialize(method, target, ast_template: nil, **args)
-      @target       = to_expression(target)
       @method       = method
-      @ast_template = ast_template
       @args         = args
+      @target       = to_expression(target)
+      @ast_template = ast_template
     end
 
     def to_ast
       if ast_template
-        { method => ast_template.call(target.to_ast, **args) }
+        { method => ast_template.call(target, **args) }
       else
-        { method => target.to_ast }
+        { method => target }
       end
     end
   end

data/lib/mongo_ql/expression/unary.rb

@@ -10,7 +10,7 @@ module MongoQL
     end
 
     def to_ast
-      { operator => right_node.to_ast }
+      { operator => right_node }
     end
   end
 end

data/lib/mongo_ql/expression/value_node.rb

@@ -2,14 +2,32 @@
 
 module MongoQL
   class Expression::ValueNode < Expression
+    SUPPORTED_TYPES = [
+      String, Integer, Float,
+      Array, Hash, TrueClass,
+      FalseClass, Date, Symbol,
+      MongoQL::Expression::ValueNode
+    ].freeze
+
     attr_accessor :value
 
     def initialize(val)
+      Expression::ValueNode.valid!(val)
       @value = val
     end
 
     def to_ast
       value
     end
+
+    def self.valid?(value)
+      SUPPORTED_TYPES.any? { |type| value.is_a?(type) }
+    end
+
+    def self.valid!(value)
+      unless valid?(value)
+        raise InvalidValueExpression, "#{value} must be in type #{SUPPORTED_TYPES.map(&:name).join(",")}"
+      end
+    end
   end
 end

data/lib/mongo_ql/expression.rb

@@ -43,7 +43,7 @@ module MongoQL
 
     def if_null(default_val)
       Expression::MethodCall.new "$ifNull", self, ast_template: -> (target, **_args) {
-        [target, to_expression(default_val).to_ast]
+        [target, to_expression(default_val)]
       }
     end
     alias_method :default, :if_null

data/lib/mongo_ql/stage/add_fields.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module MongoQL
+  class Stage::AddFields < Stage
+    attr_accessor :ctx
+    attr_accessor :field_projections
+
+    def initialize(ctx, *fields)
+      @ctx = ctx
+      @field_projections = fields.map do |field|
+                              case field
+                              when Hash
+                                field.map { |k, v| [k.to_s, to_expression(v)] }.to_h
+                              else
+                                raise ArgumentError, "#{field} is not a valid field mapping option"
+                              end
+                            end.inject({}) { |p, c| p.merge(c) }
+    end
+
+    def to_ast
+      ast = { "$addFields" => field_projections }
+      MongoQL::Utils.deep_transform_values(ast, &MongoQL::EXPRESSION_TO_AST_MAPPER)
+    end
+  end
+end

data/lib/mongo_ql/stage/group.rb

@@ -2,21 +2,22 @@
 
 module MongoQL
   class Stage::Group < Stage
-    EXPRESSION_TO_AST_MAPPER = proc { |v| v.is_a?(Expression) ? v.to_ast : v  }
-
+    attr_accessor :ctx
     attr_accessor :by, :fields
 
-    def initialize(by, arrow_fields = {}, **fields)
+    def initialize(ctx, by, arrow_fields = {}, **fields)
+      @ctx    = ctx
       @by     = by
       @fields = fields.transform_keys(&:to_s).merge(arrow_fields.transform_keys(&:to_s))
     end
 
     def to_ast
-      {
+      ast = {
         "$group" => {
           "_id" => by.to_ast,
-        }.merge(fields.transform_values(&EXPRESSION_TO_AST_MAPPER))
+        }.merge(fields)
       }
+      MongoQL::Utils.deep_transform_values(ast, &MongoQL::EXPRESSION_TO_AST_MAPPER)
     end
   end
 end

data/lib/mongo_ql/stage/lookup.rb

@@ -32,15 +32,18 @@ module MongoQL
         end
     end
 
-    attr_accessor :from, :condition, :as, :nested_pipeline_block, :let_vars
+    attr_accessor :ctx, :from, :condition, :as,
+      :nested_pipeline_block, :let_vars, :nested_pipeline
 
-    def initialize(from, condition = nil, on: nil, as: nil, &block)
+    def initialize(ctx, from, condition = nil, on: nil, as: nil, &block)
+      @ctx       = ctx
       @from      = collection_name(from)
       @as        = new_array_name(as)
       @nested_pipeline_block = block
 
       if has_nested_pipeline?
         @let_vars = NestedPipelineVars.new
+        @nested_pipeline = eval_nested_pipeline
       else
         @condition = condition_ast(condition || on)
       end
@@ -49,12 +52,13 @@ module MongoQL
     def to_ast
       lookup_expr = { "from" => from, "as" => as }
       if has_nested_pipeline?
-        lookup_expr["pipeline"] = nested_pipeline.to_ast
+        lookup_expr["pipeline"] = nested_pipeline
         lookup_expr["let"]      = let_vars.vars
       else
         lookup_expr = lookup_expr.merge(condition)
       end
-      { "$lookup" => lookup_expr }
+      ast = { "$lookup" => lookup_expr }
+      MongoQL::Utils.deep_transform_values(ast, &MongoQL::EXPRESSION_TO_AST_MAPPER)
     end
 
     private
@@ -62,7 +66,7 @@ module MongoQL
         condition.nil? && !nested_pipeline_block.nil?
       end
 
-      def nested_pipeline
+      def eval_nested_pipeline
         sub_ctx = StageContext.new
         sub_ctx.instance_exec(let_vars, &nested_pipeline_block)
         sub_ctx

data/lib/mongo_ql/stage/match.rb

@@ -2,11 +2,12 @@
 
 module MongoQL
   class Stage::Match < Stage
-    attr_accessor :conditions, :field_filters
+    attr_accessor :ctx, :conditions, :field_filters
 
-    def initialize(*conds, **field_filters)
+    def initialize(ctx, *conds, **field_filters)
+      @ctx = ctx
       conds.each do |c|
-        raise ArgumentError, "#{c.inspect} is not a MongoQL::Expression" unless c.is_a?(MongoQL::Expression)
+        raise ArgumentError, "#{c.inspect} is not a valid MongoQL::Expression" unless c.is_a?(MongoQL::Expression)
       end
       @conditions    = conds
       @field_filters = field_filters
@@ -14,18 +15,19 @@ module MongoQL
 
     def to_ast
       conds = {}
-      if conditions_ast
-        conds["$expr"] = conditions_ast
+      if compose_conditions
+        conds["$expr"] = compose_conditions
       end
-      { "$match" => conds.merge(field_filters) }
+      ast = { "$match" => conds.merge(field_filters) }
+      MongoQL::Utils.deep_transform_values(ast, &MongoQL::EXPRESSION_TO_AST_MAPPER)
     end
 
     private
-      def conditions_ast
+      def compose_conditions
         if conditions.size > 1
-          { "$and" => conditions.map(&:to_ast) }
+          { "$and" => conditions }
         elsif conditions.size == 1
-          conditions[0].to_ast
+          conditions[0]
         else
           nil
         end

data/lib/mongo_ql/stage/project.rb

@@ -2,15 +2,16 @@
 
 module MongoQL
   class Stage::Project < Stage
-    attr_accessor :field_projections
+    attr_accessor :ctx, :field_projections
 
-    def initialize(*fields)
+    def initialize(ctx, *fields)
+      @ctx = ctx
       @field_projections = fields.map do |field|
                               case field
                               when String, Symbol, Expression::FieldNode
                                 { field.to_s => 1 }
                               when Hash
-                                field.map { |k, v| [k.to_s, to_expression(v).to_ast] }.to_h
+                                field.map { |k, v| [k.to_s, to_expression(v)] }.to_h
                               else
                                 raise ArgumentError, "#{field} is not a valid field mapping option"
                               end
@@ -18,16 +19,8 @@ module MongoQL
     end
 
     def to_ast
-      { "$project" => field_projections }
+      ast = { "$project" => field_projections }
+      MongoQL::Utils.deep_transform_values(ast, &MongoQL::EXPRESSION_TO_AST_MAPPER)
     end
-
-    protected
-      def to_expression(val)
-        if val.is_a?(Expression)
-          val
-        else
-          Expression::ValueNode.new(val)
-        end
-      end
   end
 end

data/lib/mongo_ql/stage/sort.rb

@@ -2,9 +2,10 @@
 
 module MongoQL
   class Stage::Sort < Stage
-    attr_accessor :fields
+    attr_accessor :ctx, :fields
 
-    def initialize(*fields)
+    def initialize(ctx, *fields)
+      @ctx = ctx
       @fields = fields.map do |field|
         case field
         when Expression::FieldNode

data/lib/mongo_ql/stage/unwind.rb

@@ -2,20 +2,22 @@
 
 module MongoQL
   class Stage::Unwind < Stage
-    attr_accessor :path, :allow_null
+    attr_accessor :ctx, :path, :allow_null
 
-    def initialize(path, allow_null: false)
-      @path       = path.is_a?(Expression) ? path.to_ast : path
+    def initialize(ctx, path, allow_null: false)
+      @ctx        = ctx
+      @path       = to_expression(path)
       @allow_null = allow_null
     end
 
     def to_ast
-      {
+      ast = {
         "$unwind" => {
           "path" => path,
           "preserveNullAndEmptyArrays" => allow_null
         }
       }
+      MongoQL::Utils.deep_transform_values(ast, &MongoQL::EXPRESSION_TO_AST_MAPPER)
     end
   end
 end

data/lib/mongo_ql/stage.rb

@@ -2,9 +2,17 @@
 
 module MongoQL
   class Stage
-    
     def to_ast
       raise NotImplementedError, "stage #{self.class} must implement to_ast"
     end
+
+    protected
+      def to_expression(val)
+        if val.is_a?(Expression)
+          val
+        else
+          Expression::ValueNode.new(val)
+        end
+      end
   end
 end

data/lib/mongo_ql/stage_context.rb

@@ -2,42 +2,43 @@
 
 module MongoQL
   class StageContext
-    attr_accessor :pipeline
+    attr_accessor :pipeline, :injected_vars
 
     def initialize
       @pipeline = []
+      @injected_vars = {}
     end
 
     def where(*args)
-      pipeline << Stage::Match.new(*args)
+      pipeline << Stage::Match.new(self, *args)
     end
     alias_method :match, :where
 
     def add_fields(*args)
-      raise NotImplementedError, "add_fields is not implemented"
+      pipeline << Stage::AddFields.new(self, *args)
     end
 
     def project(*fields)
-      pipeline << Stage::Project.new(*fields)
+      pipeline << Stage::Project.new(self, *fields)
     end
     alias_method :select, :project
 
     def lookup(*args, &block)
-      pipeline << Stage::Lookup.new(*args, &block)
+      pipeline << Stage::Lookup.new(self, *args, &block)
     end
     alias_method :join, :lookup
 
     def group(*args)
-      pipeline << Stage::Group.new(*args)
+      pipeline << Stage::Group.new(self, *args)
     end
 
     def unwind(*args)
-      pipeline << Stage::Unwind.new(*args)
+      pipeline << Stage::Unwind.new(self, *args)
     end
     alias_method :flatten, :unwind
 
     def sort(*args)
-      pipeline << Stage::Sort.new(*args)
+      pipeline << Stage::Sort.new(self, *args)
     end
     alias_method :sort_by, :sort
 
@@ -60,12 +61,7 @@ module MongoQL
     end
 
     def to_ast
-      stages = pipeline.map(&:to_ast)
-      stages.map do |stage|
-        stage.deep_transform_values do |v|
-          v.is_a?(Expression) ? v.to_ast : v
-        end
-      end
+      pipeline.map(&:to_ast)
     end
 
     %w(where match project select sort flatten unwind lookup join).each do |m|

data/lib/mongo_ql/string_operators.rb

@@ -4,7 +4,7 @@ module MongoQL
   module StringOperators
     def substr(start, length)
       Expression::MethodCall.new "$substr", self, ast_template: -> (target, **_args) {
-        [target, to_expression(start).to_ast, to_expression(length).to_ast]
+        [target, to_expression(start), to_expression(length)]
       }
     end
 
@@ -12,14 +12,14 @@ module MongoQL
       Expression::MethodCall.new "$trim", self, ast_template: -> (target, **_args) {
         {
           "input" => target,
-          "chars" => to_expression(chars).to_ast
+          "chars" => to_expression(chars)
         }
       }
     end
 
     def concat(*expressions)
       Expression::MethodCall.new "$concat", self, ast_template: -> (target, **_args) {
-        [target, *expressions.map { |e| to_expression(e) }.map(&:to_ast)]
+        [target, *expressions.map { |e| to_expression(e) }]
       }
     end
   end

data/lib/mongo_ql/utils.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module MongoQL
+  class Utils
+    class << self
+      def deep_transform_values(value, &block)
+        case value
+        when Hash
+          value.transform_values do |val|
+            MongoQL::Utils.deep_transform_values(val, &block)
+          end
+        when Array
+          value.map do |val|
+            MongoQL::Utils.deep_transform_values(val, &block)
+          end
+        else
+          transformed_value = yield(value)
+          case transformed_value
+          when Hash
+            MongoQL::Utils.deep_transform_values(transformed_value, &block)
+          when Array
+            MongoQL::Utils.deep_transform_values(transformed_value, &block)
+          else
+            transformed_value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongo_ql/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MongoQL
-  VERSION = "0.0.4"
+  VERSION = "1.0.0"
 end

data/lib/mongo_ql.rb

@@ -1,10 +1,20 @@
 # frozen_string_literal: true
 
-require "active_support"
-require "active_support/core_ext/hash"
+require "date"
 require "logger"
 module MongoQL
-  class InvalidVariableAccess < StandardError; end
+  class MongoQLError < RuntimeError; end
+  class InvalidVariableAccess < MongoQLError; end
+  class InvalidValueExpression < MongoQLError; end
+
+  EXPRESSION_TO_AST_MAPPER = proc do |v|
+    case v
+    when Expression, Stage, StageContext
+      v.to_ast
+    else
+      v
+    end
+  end
 
   def self.compose(*variable_names, &block)
     block_binding = block.binding
@@ -16,17 +26,18 @@ module MongoQL
 
     # Update injected local variables to ValueNode expressions
     variable_names.each do |name|
-      block_binding.local_variable_set(name, Expression::ValueNode.new(variables[name]))
+      ctx.injected_vars[name] = Expression::ValueNode.new(variables[name])
+      block_binding.local_variable_set(name, ctx.injected_vars[name])
     end
 
     ctx.instance_exec(*variables, &block)
+    ctx
 
+  ensure
     # Restore local variables
     variable_names.each do |name|
       block_binding.local_variable_set(name, variables[name])
     end
-
-    ctx
   end
 
   def self.logger
@@ -35,6 +46,7 @@ module MongoQL
 end
 
 require_relative "mongo_ql/version"
+require_relative "mongo_ql/utils"
 require_relative "mongo_ql/expression"
 require_relative "mongo_ql/expression/date_note"
 require_relative "mongo_ql/expression/field_node"
@@ -54,5 +66,6 @@ require_relative "mongo_ql/stage/match"
 require_relative "mongo_ql/stage/group"
 require_relative "mongo_ql/stage/unwind"
 require_relative "mongo_ql/stage/sort"
+require_relative "mongo_ql/stage/add_fields"
 
 require_relative "mongo_ql/stage_context"

data/mongo_ql.gemspec

@@ -19,5 +19,6 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "activesupport", ">= 6.0.0"
-end
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+end

metadata

@@ -1,29 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: mongo_ql
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Xizheng Ding
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-10-17 00:00:00.000000000 Z
+date: 2019-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: '0'
 description: 
 email:
 - dingxizheng@gamil.com
@@ -33,11 +47,14 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rubocop.yml"
+- ".vscode/launch.json"
 - LICENSE.txt
 - README.md
+- Rakefile
 - Untitled-1
 - bin/console
 - bin/setup
+- debug.sh
 - design_specs.md
 - lib/mongo_ql.rb
 - lib/mongo_ql/binary_operators.rb
@@ -54,6 +71,7 @@ files:
 - lib/mongo_ql/expression/unary.rb
 - lib/mongo_ql/expression/value_node.rb
 - lib/mongo_ql/stage.rb
+- lib/mongo_ql/stage/add_fields.rb
 - lib/mongo_ql/stage/group.rb
 - lib/mongo_ql/stage/lookup.rb
 - lib/mongo_ql/stage/match.rb
@@ -63,6 +81,7 @@ files:
 - lib/mongo_ql/stage_context.rb
 - lib/mongo_ql/string_operators.rb
 - lib/mongo_ql/unary_operators.rb
+- lib/mongo_ql/utils.rb
 - lib/mongo_ql/version.rb
 - mongo_ql.gemspec
 homepage: https://github.com/dingxizheng/mongo_ql