msfl_visitors 0.1.0.rc3 → 0.3.0.dev

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 388743fe79552e7461242c26d68feb0be8160148
-  data.tar.gz: 02aad6d1b455f84874473030b0ce7770837c7d4e
+  metadata.gz: 172130f160936dc67e1d5658a17276f9e1bd6b9d
+  data.tar.gz: b86ec5deb1e85c048e418a39a3d5fa003bd36c6a
 SHA512:
-  metadata.gz: b181c89aac58514f15df5c045a40fcdb7434522a48e63c0bc2f84dc61e096163f0aa4ffb736a58b0b3ac453c6ce936d4524dcf22eb0f4042ca3cdd71b485f2ec
-  data.tar.gz: 5a394966b78902288dc6da7707f6a592c701cf9b51cd2d0b39a964a9489f2b71edf124de104151c78cd110559d00b7fa1279b29ea580782592c256c844ceb8ed
+  metadata.gz: 86d580b40f4198b2a7f62370be7c0cae80d4c374ea4e29ee04b477ab1efb1a77b889b00e38400a83e2c6d4f6e0981b24f29dbbe7285cc9bd7babcb5a676ee310
+  data.tar.gz: f336cc01362a4f87ccc8a0265c7588c517ecb1b117a735fe293b4518a661d295b29ee1b3a1f5c81630ba7976821c5a5a0c377840f5a1df2f00d7d33ffcf84d62

data/Gemfile

@@ -3,4 +3,4 @@ gem 'simplecov', :require => false, :group => :test           # MIT https://gith
 gem 'yard'                                                    # MIT https://github.com/lsegal/yard/blob/master/LICENSE + Ruby license for one file from the Ruby source lib/parser/ruby/legacy/ruby_lex.rb
 gem 'rspec'                                                   # MIT https://github.com/rspec/rspec/blob/master/License.txt
 gem 'byebug'
-gem 'msfl', "~> 1.1"
+gem 'msfl', "1.2.0.dev4"

data/Gemfile.lock

@@ -7,7 +7,7 @@ GEM
     diff-lcs (1.2.5)
     docile (1.1.5)
     json (1.8.2)
-    msfl (1.1.6)
+    msfl (1.2.0.dev4)
       json (~> 1.7)
     rspec (3.2.0)
       rspec-core (~> 3.2.0)
@@ -34,7 +34,7 @@ PLATFORMS
 
 DEPENDENCIES
   byebug
-  msfl (~> 1.1)
+  msfl (= 1.2.0.dev4)
   rspec
   simplecov
   yard

data/README.md

@@ -5,23 +5,18 @@ A visitor pattern based approach for converting MSFL to other forms
 
 ## Usage
 
- ```ruby
- # This is not actually working code yet! @todo revisit once Matt's refactor branch is merged.
- require 'msfl_visitor'
+```ruby
+require 'msfl_visitor'
 
- filter = { make: "Toyota" }
+filter    = { make: "Toyota" }
 
- collector = String.new
+visitor   = MSFLVisitors::Visitor.new 
 
- renderer = MSFLVisitors::Renderers::Chewy::TermFilter.new
+visitor.visit_tree MSFLVisitors::AST.new(filter)
 
- visitor = MSFLVisitors::Visitor.new collector, renderer
+=> [{clause: 'make == "Toyota"'}]
 
- MSFLVisitors::AST.new(filter).accept(visitor)
-
- => 'make == "Toyota"'
-
- ```
+```
 
 ## Architecture
 
@@ -54,11 +49,8 @@ multiple output DSLs.
 
 ## collector
 
-During traversal the output from each node needs to be stored or buffered somewhere. The collector serves this role.
-It can be as simple as a String or an Array, or it can be more elaborate. Ultimately it must respond to the shovel
-operator (<<)
+Removed as of 0.3
 
 ## renderer
 
-The logic for rendering the AST nodes into the output DSL is codified in a renderer. The two principle renderers at
-this time are Chewy::TermFilter and Chewy:QueryStringFilter
+Removed as of 0.3

data/lib/msfl_visitors/nodes/and.rb

@@ -2,23 +2,6 @@ require_relative 'iterator'
 module MSFLVisitors
   module Nodes
     class And < Iterator
-
-      def accept(visitor)
-        nodes = Array.new
-        if set.count > 1
-          set.each do |item|
-            nodes << MSFLVisitors::Nodes::Grouping::Grouping.new(item)
-            nodes << BinaryAnd.new
-          end
-          nodes.pop
-        elsif set.count == 1
-          nodes << set.first
-        end
-
-        nodes.each do |node|
-          node.accept visitor
-        end
-      end
     end
   end
 end

data/lib/msfl_visitors/nodes/base.rb

@@ -1,7 +1,9 @@
 module MSFLVisitors
   module Nodes
     class Base
-
+      def accept(visitor)
+        visitor.visit(self)
+      end
     end
   end
 end

data/lib/msfl_visitors/nodes/binary.rb

@@ -2,15 +2,8 @@ require_relative 'base'
 module MSFLVisitors
   module Nodes
     class Binary < Base
-
       attr_accessor :left, :right
 
-      def accept(visitor)
-        left.accept visitor
-        visitor.visit self
-        right.accept visitor
-      end
-
       def initialize(left, right)
         self.left = left
         self.right = right

data/lib/msfl_visitors/nodes/dataset.rb

@@ -0,0 +1,7 @@
+require_relative 'value'
+module MSFLVisitors
+  module Nodes
+    class Dataset < Value
+    end
+  end
+end

data/lib/msfl_visitors/nodes/equal.rb

@@ -2,6 +2,23 @@ require_relative 'comparison'
 module MSFLVisitors
   module Nodes
     class Equal < Comparison
+
+      def accept(visitor)
+        visitor.visit self
+        #
+        # case visitor.current_visitor
+        #   when Visitors::Chewy::TermFilter
+        #     super
+        #
+        #   when Visitors::Chewy::Aggregations
+        #     @value = { left.accept(visitor) => right.accept(visitor) }
+        #     visitor.visit(self)
+        #
+        #   else
+        #     fail ArgumentError, "Unknown current visitor type."
+        # end
+      end
+
     end
   end
 end

data/lib/msfl_visitors/nodes/explicit_filter.rb

@@ -0,0 +1,7 @@
+require_relative 'filter'
+module MSFLVisitors
+  module Nodes
+    class ExplicitFilter < Filter
+    end
+  end
+end

data/lib/msfl_visitors/nodes/filter.rb

@@ -1,20 +1,21 @@
-require_relative 'set/set'
+require_relative 'base'
 module MSFLVisitors
   module Nodes
-    class Filter < Set::Set
-      def accept(visitor)
-        nodes = Array.new
-        if contents.count > 0
-          contents.each do |item|
-            nodes << item
-            nodes << Set::Delimiter.new
-          end
-          # Remove the last (and therefore extra) delimiter
-          nodes.pop
-        end
-        nodes.each do |node|
-          node.accept visitor
-        end
+    class Filter < Base
+      extend Forwardable
+
+      attr_accessor :contents
+
+      def_delegators :contents, :count, :first, :each
+
+      # @param nodes [Array<MSFL::Nodes::Base>] the nodes that the filter surrounds
+      def initialize(nodes)
+        self.contents = Array(nodes)
+      end
+
+      def ==(other)
+        self.class == other.class &&
+            contents == other.contents
       end
     end
   end

data/lib/msfl_visitors/nodes/foreign.rb

@@ -0,0 +1,7 @@
+require_relative 'binary'
+module MSFLVisitors
+  module Nodes
+    class Foreign < Binary
+    end
+  end
+end

data/lib/msfl_visitors/nodes/given.rb

@@ -0,0 +1,7 @@
+require_relative 'filter'
+module MSFLVisitors
+  module Nodes
+    class Given < Filter
+    end
+  end
+end

data/lib/msfl_visitors/nodes/iterator.rb

@@ -5,8 +5,14 @@ module MSFLVisitors
 
       attr_accessor :set
 
-      # @param set [MSFLVisitors::Nodes::Set::Set] a set node that allows its elements to be iterated over
+      # Be extra defensive, because even after adding previous comment I still tend to make the mistake of
+      # passing in an array.
+      #
+      # @param set [MSFLVisitors::Nodes::Set] a set node that allows its elements to be iterated over
       def initialize(set)
+        unless set.is_a? MSFLVisitors::Nodes::Set
+          fail ArgumentError, "Argument to Iterator initialize must be instance of MSFLVisitors::Nodes::Set"
+        end
         self.set = set
       end
 

data/lib/msfl_visitors/nodes/named_value.rb

@@ -0,0 +1,16 @@
+module MSFLVisitors
+  module Nodes
+    class NamedValue
+      attr_accessor :name, :value
+
+      def initialize(name, value)
+        self.name = name
+        self.value = value
+      end
+
+      def accept(visitor)
+        visitor.visit(self)
+      end
+    end
+  end
+end

data/lib/msfl_visitors/nodes/partial.rb

@@ -0,0 +1,7 @@
+require_relative 'binary'
+module MSFLVisitors
+  module Nodes
+    class Partial < Binary
+    end
+  end
+end

data/lib/msfl_visitors/nodes/set.rb

@@ -0,0 +1,23 @@
+require_relative 'base'
+module MSFLVisitors
+  module Nodes
+    class Set < Base
+
+      extend Forwardable
+
+      attr_accessor :contents
+
+      def_delegators :contents, :count, :first, :each
+
+      # @param nodes [Array<MSFL::Nodes::Base>] the nodes that the filter surrounds
+      def initialize(nodes)
+        self.contents = Array(nodes)
+      end
+
+      def ==(other)
+        self.class == other.class &&
+            contents == other.contents
+      end
+    end
+  end
+end

data/lib/msfl_visitors/nodes.rb

@@ -2,30 +2,28 @@
 require_relative 'nodes/and'
 require_relative 'nodes/base'
 require_relative 'nodes/binary'
-require_relative 'nodes/binary_and'
 require_relative 'nodes/boolean'
 require_relative 'nodes/comparison'
-require_relative 'nodes/constant_value'
 require_relative 'nodes/containment'
+require_relative 'nodes/dataset'
 require_relative 'nodes/date'
 require_relative 'nodes/date_time'
 require_relative 'nodes/equal'
+require_relative 'nodes/explicit_filter'
 require_relative 'nodes/field'
 require_relative 'nodes/filter'
+require_relative 'nodes/foreign'
+require_relative 'nodes/given'
 require_relative 'nodes/iterator'
 require_relative 'nodes/greater_than'
 require_relative 'nodes/greater_than_equal'
-require_relative 'nodes/grouping/close'
-require_relative 'nodes/grouping/grouping'
-require_relative 'nodes/grouping/open'
 require_relative 'nodes/less_than'
 require_relative 'nodes/less_than_equal'
+require_relative 'nodes/named_value'
 require_relative 'nodes/number'
+require_relative 'nodes/partial'
 require_relative 'nodes/range_value'
-require_relative 'nodes/set/close'
-require_relative 'nodes/set/delimiter'
-require_relative 'nodes/set/set'
-require_relative 'nodes/set/open'
+require_relative 'nodes/set'
 require_relative 'nodes/time'
 require_relative 'nodes/value'
 require_relative 'nodes/word'

data/lib/msfl_visitors/parsers/msfl_parser.rb

@@ -10,6 +10,11 @@ module MSFLVisitors
           lt:         Nodes::LessThan,
           lte:        Nodes::LessThanEqual,
           in:         Nodes::Containment,
+          foreign:    Nodes::Foreign,
+          dataset:    Nodes::Dataset,
+          filter:     Nodes::ExplicitFilter,
+          given:      Nodes::Given,
+          partial:    Nodes::Partial,
 
       }
 
@@ -34,10 +39,14 @@ module MSFLVisitors
       end
 
 
-
+      def initialize(dataset = nil)
+        @dataset = dataset
+      end
 
     private
 
+      attr_accessor :dataset
+
       def parse_Hash(obj, lhs = false)
         nodes = Array.new
         obj.each do |k, v|
@@ -57,14 +66,34 @@ module MSFLVisitors
         obj.each do |item|
           nodes << parse(item)
         end
-        MSFLVisitors::Nodes::Set::Set.new nodes
+        MSFLVisitors::Nodes::Set.new nodes
       end
 
+      # A key/value pair needs to be parsed and handled while iterating across the Hash that the key/value pair belong to
+      # lhs is for when the field is a parent of the actual operator node
+      # ex. { year: { gte: 2010 } } needs to be converted to (gte(year, 2010)) -- infix operators to RPN
       def hash_dispatch(key, value, lhs = false)
         if OPERATORS_TO_NODE_CLASS.include? key
           # Detect the node type, forward the lhs if it was passed in (essentially when the operator is a binary op)
-          args = [lhs, parse(value)] if lhs
-          args ||= [parse(value)]
+          case key
+            when :foreign
+              args = [hash_dispatch(:dataset, value[:dataset]), hash_dispatch(:filter, value[:filter])]
+
+            when :partial
+              args = [hash_dispatch(:given, value[:given]), hash_dispatch(:filter, value[:filter])]
+
+            when :dataset
+              args = [value]
+            when :filter, :given
+              # Explicit Filter
+              # ex { foreign: { dataset: "person", filter: { age: 25 } } }
+              # ex { partial: { given: { make: "Toyota" }, filter: { avg_age: 10 } } }
+              args = value.map { |k,v| hash_dispatch(k,v) }
+            else
+              # fall back to a Filter Node
+              args = [lhs, parse(value)] if lhs
+              args ||= [parse(value)]
+          end
           OPERATORS_TO_NODE_CLASS[key].new(*args)
         else
           # the key is a field

data/lib/msfl_visitors/visitor.rb

@@ -1,16 +1,175 @@
+require 'forwardable'
 module MSFLVisitors
   class Visitor
-    def initialize(collector, renderer)
-      @collector = collector
-      @renderer = renderer
+
+    attr_accessor :clauses, :current_clause
+    attr_writer :mode
+
+    def initialize
+      self.mode = :term # or :aggregations
+      self.clauses = Array.new
+
+    end
+
+    def visit(node)
+      case node
+        when Nodes::Partial
+          in_aggregation_mode do
+            clauses << { clause: get_visitor.visit(node), method_to_execute: :aggregations }
+            ""
+          end
+        else
+          get_visitor.visit(node)
+      end
+    end
+
+    def get_visitor
+      (mode == :term ? TermFilterVisitor : AggregationsVisitor).new(self)
     end
 
-    def visit(obj)
-      collector << renderer.render(obj)
+    def in_aggregation_mode
+      self.mode = :aggregations
+      result = yield if block_given?
+      self.mode = :term
+      result
+    end
+
+    def visit_tree(root)
+      [{clause: root.accept(self)}].concat(clauses).reject { |c| c[:clause] == "" }
     end
 
     private
 
-    attr_reader :collector, :renderer
+    attr_reader :mode
+
+    class TermFilterVisitor
+      def initialize(visitor)
+        @visitor = visitor
+      end
+
+      BINARY_OPERATORS = {
+          Nodes::Containment            => '==',
+          Nodes::GreaterThan            => '>',
+          Nodes::GreaterThanEqual       => '>=',
+          Nodes::Equal                  => '==',
+          Nodes::LessThan               => '<',
+          Nodes::LessThanEqual          => '<=',
+      }
+
+      def visit(node)
+        case node
+          when  Nodes::Field
+            node.value.to_s
+          when  Nodes::Word
+            "\"#{node.value}\""
+          when Nodes::Date, Nodes::Time
+            "\"#{node.value.iso8601}\""
+          when  Nodes::Number, Nodes::Boolean
+            node.value
+          when  Nodes::Containment,
+                Nodes::GreaterThan,
+                Nodes::GreaterThanEqual,
+                Nodes::Equal,
+                Nodes::LessThan,
+                Nodes::LessThanEqual
+            "#{node.left.accept(visitor)} #{BINARY_OPERATORS[node.class]} #{node.right.accept(visitor)}"
+          when  Nodes::Set
+            "[ " + node.contents.map { |n| n.accept(visitor) }.join(" , ") + " ]"
+          when Nodes::Filter
+            if node.contents.count == 1
+              node.contents.first.accept(visitor)
+            else
+              node.contents.map { |n| "( " + n.accept(visitor) + " )" }.join(" & ")
+            end
+
+          when Nodes::And
+            if node.set.contents.count == 1
+              node.set.contents.first.accept(visitor)
+            else
+              node.set.contents.map { |n| "( " + n.accept(visitor) + " )" }.join(" & ")
+            end
+
+          when Nodes::Foreign
+            "#{node.left.accept visitor}.filter { #{node.right.accept visitor} }"
+
+          when Nodes::Dataset
+            "has_child( :#{node.value} )"
+
+          else
+            fail ArgumentError, "TERMFILTER cannot visit: #{node.class.name}"
+        end
+      end
+
+      private
+
+      attr_reader :visitor
+    end
+
+    class AggregationsVisitor
+      def initialize(visitor)
+        @visitor = visitor
+      end
+
+      RANGE_OPERATORS = {
+          Nodes::GreaterThan            => :gt,
+          Nodes::GreaterThanEqual       => :gte,
+          Nodes::LessThan               => :lt,
+          Nodes::LessThanEqual          => :lte,
+      }
+
+      def visit(node)
+        case node
+          when Nodes::Partial
+            { given: Hash[[node.left.accept(visitor), node.right.accept(visitor)]] }
+
+          when Nodes::Equal
+            { term: { node.left.accept(visitor) => node.right.accept(visitor) } }
+            # [{ clause:  }]
+          when Nodes::Field
+            node.value.to_sym
+          when Nodes::Date, Nodes::Time
+            node.value.iso8601
+          when  Nodes::Word,
+                Nodes::Number,
+                Nodes::Boolean,
+                Nodes::Dataset
+            node.value
+          when  Nodes::GreaterThan,
+                Nodes::GreaterThanEqual,
+                Nodes::LessThan,
+                Nodes::LessThanEqual
+            { range: { node.left.accept(visitor) => { RANGE_OPERATORS[node.class] =>  node.right.accept(visitor) } } }
+          when Nodes::Given
+            [:filter, node.contents.first.accept(visitor)]
+          when Nodes::ExplicitFilter
+            [:filter, node.contents.map { |n| n.accept(visitor) }.reduce({}) { |hsh, x| hsh.merge!(x); hsh } ]
+          when Nodes::NamedValue
+            [:aggs, {node.name.accept(visitor).to_sym => Hash[[node.value.accept(visitor)]]}]
+          when Nodes::Containment
+            { terms: {node.left.accept(visitor).to_sym => node.right.accept(visitor)} }
+          when Nodes::Set
+            node.contents.map { |n| n.accept(visitor) }
+          when Nodes::Filter
+            if node.contents.count == 1
+              node.contents.first.accept visitor
+            else
+              { and: node.contents.map { |n| n.accept(visitor) } }
+            end
+          when Nodes::And
+            { and: node.set.accept(visitor) }
+
+          when Nodes::Foreign
+            { has_child: Hash[[[:type, node.left.accept(visitor)], node.right.accept(visitor)]] }
+
+          else
+            fail ArgumentError, "AGGREGATIONS cannot visit: #{node.class.name}"
+        end
+      end
+
+      private
+
+      attr_reader :visitor
+    end
   end
 end
+

data/lib/msfl_visitors.rb

@@ -1,9 +1,7 @@
 require_relative 'msfl_visitors/ast'
 require_relative 'msfl_visitors/nodes'
 require_relative 'msfl_visitors/visitor'
-require_relative 'msfl_visitors/renderers/chewy/term_filter'
 require_relative 'msfl_visitors/parsers/msfl_parser'
-require_relative 'msfl_visitors/collectors'
 
 module MSFLVisitors
 end

data/msfl_visitors.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name        = 'msfl_visitors'
-  s.version     = '0.1.0.rc3'
-  s.date        = '2015-05-11'
+  s.version     = '0.3.0.dev'
+  s.date        = '2015-05-15'
   s.summary     = "Convert MSFL to other forms"
   s.description = "Visitor pattern approach to converting MSFL to other forms."
   s.authors     = ["Courtland Caldwell"]
@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.homepage    =
       'https://github.com/Referly/msfl_visitors'
-  s.add_runtime_dependency "msfl", "~> 1.1", '>= 1.1.6'
+  s.add_runtime_dependency "msfl", "~> 1.2"
   s.add_development_dependency "rake", "~> 10.3"
   s.add_development_dependency "simplecov", "~> 0.10"
   s.add_development_dependency "yard", "~> 0.8"

data/spec/nodes/iterator_spec.rb

@@ -2,15 +2,33 @@ require 'spec_helper'
 
 describe MSFLVisitors::Nodes::Iterator do
 
+  describe ".new" do
+
+    subject { described_class.new arg }
+
+    context "when the argument is not a MSFLVisitors::Nodes::Set instance" do
+
+      let(:arg) { double('Not a Set node') }
+
+      it "raises an ArgumentError" do
+        expect { subject }.to raise_error ArgumentError
+      end
+    end
+  end
+
   describe "#==" do
 
     let(:one) { MSFLVisitors::Nodes::Number.new(1) }
 
     let(:two) { MSFLVisitors::Nodes::Number.new(2) }
 
-    let(:left) { MSFLVisitors::Nodes::Iterator.new [one, two] }
+    let(:left) { MSFLVisitors::Nodes::Iterator.new left_set }
+
+    let(:left_set) { MSFLVisitors::Nodes::Set.new [one, two] }
+
+    let(:right) { MSFLVisitors::Nodes::Iterator.new right_set }
 
-    let(:right) { MSFLVisitors::Nodes::Iterator.new [one, two] }
+    let(:right_set) { MSFLVisitors::Nodes::Set.new [one, two] }
 
     subject { left == right }
 
@@ -23,7 +41,7 @@ describe MSFLVisitors::Nodes::Iterator do
 
       context "when lhs#items is not equal to rhs#items" do
 
-        let(:right) {  MSFLVisitors::Nodes::Iterator.new [one] }
+        let(:right_set) { MSFLVisitors::Nodes::Set.new [one] }
 
         it { is_expected.to be false }
       end