Add pipeline parameter builder

tomeroth · blelump · commit b6ba364f4c4c · 2017-09-06T11:18:24.000+02:00
diff --git a/examples/interpreter/to_sql.rb b/examples/interpreter/to_sql.rb
@@ -29,6 +29,7 @@ def visit_root(_value, left, _right)
 
     # @api private
     def visit_statement(value, left, right)
+      return visit(left) if right.nil?
       case value
       when :and
         "#{visit(left)} AND #{visit(right)}"
diff --git a/lib/filterly.rb b/lib/filterly.rb
@@ -3,6 +3,7 @@
 require 'filterly/parser'
 require 'filterly/tree'
 require 'filterly/node_builder'
+require 'filterly/pipeline/param_builder'
 
 module Filterly
   # Your code goes here...
diff --git a/lib/filterly/node_builder.rb b/lib/filterly/node_builder.rb
@@ -79,18 +79,21 @@ def self.build_custom_node(type:, args:)
 
     # @api private
     def self.attr_array(array_of_values)
-      Filterly::Node.new(:attr_array, [nil, ast_array(array_of_values), nil])
+      Filterly::Node.new(
+        :attr_array,
+        attr_array_params(array_of_values)
+      )
     end
 
     # @api private
     def self.ast_array(params)
       return if params.nil?
-      return Filterly::Node.new(:attr_value, [params, nil, nil]) unless
+      return Filterly::Node.new(:attr_array, [params, nil, nil]) unless
         params.is_a?(Array)
 
       return if params.empty?
 
-      Filterly::Node.new(:attr_value, attr_array_params(params))
+      Filterly::Node.new(:attr_array, attr_array_params(params))
     end
 
     # @api private
diff --git a/lib/filterly/pipeline/param_builder.rb b/lib/filterly/pipeline/param_builder.rb
@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Filterly
+  module Pipeline
+    class ParamBuilder
+      attr_reader :filters, :from, :order, :params
+
+      def initialize(filters:, from:, order:, params:)
+        @filters = filters
+        @from = from
+        @order = order
+        @params = params
+      end
+
+      def limit
+        params[:limit]
+      end
+
+      def offset
+        params[:offset]
+      end
+
+      def search_query
+        params[:search_query]
+      end
+
+      def self.new
+        super(
+          filters: Filterly::Tree.initialize_with_filters,
+          from: Set.new,
+          order: Set.new,
+          params: { limit: 10, offset: 0, search_query: nil }
+        )
+      end
+
+      def append(deps)
+        deps.each do |k, v|
+          case k
+          when :filters
+            @filters.prepend_ast(Filterly::Parser.new(v).to_ast, :and)
+          when :from
+            @from << v
+          when :order
+            @order << v
+          when :params
+            @params = @params.merge(v)
+          end
+        end
+      end
+
+      alias << append
+    end
+  end
+end
diff --git a/lib/filterly/tree.rb b/lib/filterly/tree.rb
@@ -4,11 +4,10 @@
 
 module Filterly
   class Tree
-    attr_reader :root_node, :tree_traverser
+    attr_reader :root_node
 
     def initialize(root_node)
       @root_node = root_node
-      @tree_traverser = TreeTraverser.new(root_node)
     end
 
     def self.new(root_node)
@@ -18,12 +17,23 @@ def self.new(root_node)
       super(root_node)
     end
 
+    def self.initialize_with_filters
+      new(
+        Filterly::NodeBuilder.build_custom_node(
+          type: :root,
+          args: [:filters, nil, nil]
+        )
+      )
+    end
+
     def extend_ast(node_attr_name, new_node, stmt_type)
-      @root_node = tree_traverser.extend_ast(node_attr_name, new_node, stmt_type)
+      @root_node = TreeTraverser
+        .new(@root_node)
+        .extend_ast(node_attr_name, new_node, stmt_type)
     end
 
     def prepend_ast(new_node, stmt_type)
-      @root_node = tree_traverser.prepend_ast(new_node, stmt_type)
+      @root_node = TreeTraverser.new(@root_node).prepend_ast(new_node, stmt_type)
     end
 
     def to_ast
@@ -73,13 +83,13 @@ def recreate_node(node_attr_name, new_node, stmt_type)
           [
             ast_node.value,
             self
-              .class
-              .new(ast_node.left)
-              .extend_ast(node_attr_name, new_node, stmt_type),
+            .class
+            .new(ast_node.left)
+            .extend_ast(node_attr_name, new_node, stmt_type),
             self
-              .class
-              .new(ast_node.right)
-              .extend_ast(node_attr_name, new_node, stmt_type)
+            .class
+            .new(ast_node.right)
+            .extend_ast(node_attr_name, new_node, stmt_type)
           ]
         )
       end
diff --git a/spec/examples/interpreter_spec.rb b/spec/examples/interpreter_spec.rb
@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 require 'filterly/node'
-require File.join Examples.root, 'interpreter'
+require 'examples/interpreter'
 
 RSpec.describe Interpreter do
   subject do
diff --git a/spec/examples/to_sql/expression_factory_spec.rb b/spec/examples/to_sql/expression_factory_spec.rb
@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 require 'filterly/node'
-require File.join Examples.root, 'interpreter/to_sql/expression_factory'
+require 'examples/interpreter/to_sql/expression_factory'
 
 RSpec.describe Interpreter::ToSql::ExpressionFactory do
   subject do
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift('.')
+
 require "bundler/setup"
 require "filterly"
 
@@ -12,9 +16,3 @@
     c.syntax = :expect
   end
 end
-
-class Examples
-  def self.root
-    File.join (File.dirname __dir__), 'examples'
-  end
-end
diff --git a/spec/unit/node_builder_spec.rb b/spec/unit/node_builder_spec.rb
@@ -102,21 +102,22 @@
             [:attr_name, ['course_id', [], []]],
             [
               :attr_array, [
-                nil,
+                12,
                 [
-                  :attr_value, [
-                    12,
-                    [:attr_value, [1, [], []]],
-                    [
-                      :attr_value, [
-                        3,
-                        [:attr_value, [4, [], []]],
-                        []
-                      ]
-                    ]
+                  :attr_array, [
+                    1,
+                    [],
+                    []
                   ]
                 ],
-                []
+                [
+                  :attr_array,
+                  [
+                    3,
+                    [:attr_array, [4, [], []]],
+                    []
+                  ]
+                ]
               ]
             ]
           ]
diff --git a/spec/unit/parser_spec.rb b/spec/unit/parser_spec.rb
@@ -37,16 +37,16 @@
                     [
                       :attr_array,
                       [
-                        nil,
+                        12,
                         [
-                          :attr_value,
+                          :attr_array,
                           [
-                            12,
-                            [:attr_value, [34, [], []]],
-                            [:attr_value, [54, [], []]]
+                            34,
+                            [],
+                            []
                           ]
                         ],
-                        []
+                        [:attr_array, [54, [], []]]
                       ]
                     ]
                   ]
diff --git a/spec/unit/pipeline/param_builder_spec.rb b/spec/unit/pipeline/param_builder_spec.rb
@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'filterly/pipeline/param_builder'
+
+RSpec.describe Filterly::Pipeline::ParamBuilder do
+  subject do
+    described_class.new
+  end
+
+  let(:new_params) do
+    {
+      filters: {
+        category_ids: [12, 34, 54],
+        course_semester_id: 123
+      },
+      from: 'courses',
+      order: { 'courses.id': 'asc' },
+      params: {
+        limit: 10,
+        offset: 0,
+        search_query: 'adam',
+        not_supported: 'omitted'
+      },
+      ingored_one: 'none'
+    }
+  end
+
+  describe '#initialize' do
+    it 'creates root node for fitlers ast tree' do
+      expect(subject.filters.to_ast.to_a).to match_array([:root, [:filters, [], []]])
+    end
+  end
+
+  describe '#append' do
+    it 'appends filters, from, order and params while ignoring other keys' do
+      subject << new_params
+      subject << { filters: { course_timetable: '2017-03-03' } }
+      subject << { order: { 'another_col': 'desc' } }
+      subject << { params: { limit: 3 } }
+
+      expect(subject.from).to match_array(['courses'])
+      expect(subject.limit).to eql(3)
+      expect(subject.offset).to eql(0)
+      expect(subject.search_query).to eql('adam')
+
+      expect(subject.order).to match_array(
+        [
+          { 'courses.id': 'asc' },
+          { 'another_col': 'desc' }
+        ]
+      )
+
+      expect(subject.filters.root_node.to_a).to match_array(
+        [
+          :root,
+          [
+            :filters,
+            [
+              :statement,
+              [
+                :and,
+                [
+                  :expression,
+                  [
+                    :op_equal,
+                    [:attr_name, [:course_timetable, [], []]],
+                    [:attr_value, ['2017-03-03', [], []]]
+                  ]
+                ],
+                [
+                  :statement,
+                  [
+                    :and,
+                    [
+                      :statement,
+                      [
+                        :and,
+                        [
+                          :expression,
+                          [
+                            :op_in,
+                            [:attr_name, [:category_ids, [], []]],
+                            [
+                              :attr_array,
+                              [
+                                12,
+                                [:attr_array, [34, [], []]],
+                                [:attr_array, [54, [], []]]
+                              ]
+                            ]
+                          ]
+                        ],
+                        [
+                          :expression,
+                          [
+                            :op_equal,
+                            [:attr_name, [:course_semester_id, [], []]],
+                            [:attr_value, [123, [], []]]
+                          ]
+                        ]
+                      ]
+                    ],
+                    []
+                  ]
+                ]
+              ]
+            ],
+            []
+          ]
+        ]
+      )
+    end
+  end
+end
diff --git a/spec/unit/tree_spec.rb b/spec/unit/tree_spec.rb
@@ -83,6 +83,21 @@
     end
   end
 
+  describe '#initialize_with_filters' do
+    it 'initializes Tree with filters root' do
+      expect(described_class.initialize_with_filters.root_node.to_a).to match_array(
+        [
+          :root,
+          [
+            :filters,
+            [],
+            []
+          ]
+        ]
+      )
+    end
+  end
+
   describe '#extend_ast' do
     it 'adds a new node to specific node and returns root' do
       subject.extend_ast(node_attr_name, new_node, :or)

Original file line number	Diff line number	Diff line change
`@@ -37,16 +37,16 @@`
`37`	`37`	`[`
`38`	`38`	`:attr_array,`
`39`	`39`	`[`
`40`		`- nil,`
	`40`	`+ 12,`
`41`	`41`	`[`
`42`		`- :attr_value,`
	`42`	`+ :attr_array,`
`43`	`43`	`[`
`44`		`- 12,`
`45`		`- [:attr_value, [34, [], []]],`
`46`		`- [:attr_value, [54, [], []]]`
	`44`	`+ 34,`
	`45`	`+ [],`
	`46`	`+ []`
`47`	`47`	`]`
`48`	`48`	`],`
`49`		`- []`
	`49`	`+ [:attr_array, [54, [], []]]`
`50`	`50`	`]`
`51`	`51`	`]`
`52`	`52`	`]`