msfl_visitors 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 095f9e51f9996a5555813581c265dbf5633b2272
+  data.tar.gz: 59c199f8df4b4f53bfe8b332d430c3e3e502476e
+SHA512:
+  metadata.gz: a41e25d060824497a403ffa1f0f7b65a2856322e1dbc45819409e441559e1c9704bd024c92d37cf1bf861d8d06726609354906c90dd8e7432a9a3e3425c7c592
+  data.tar.gz: c602d663fdcc0864218ae9825362cc3c4917c26b7cbbbf959f33419704d4135d9ff9c81f80a6aa7a756ecb26364dfa50d99b9942e38e7889f482345ad6fccd46

data/.gitignore

@@ -0,0 +1,20 @@
+### Ruby template
+*.gem
+*.rbc
+/coverage/
+/spec/reports/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+.idea/
+
+## Gemfile for development
+#Gemfile
+#Gemfile.lock

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+gem 'simplecov', :require => false, :group => :test           # MIT https://github.com/colszowka/simplecov/blob/master/MIT-LICENSE
+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"

data/Gemfile.lock

@@ -0,0 +1,40 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (4.0.5)
+      columnize (= 0.9.0)
+    columnize (0.9.0)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    json (1.8.2)
+    msfl (1.1.6)
+      json (~> 1.7)
+    rspec (3.2.0)
+      rspec-core (~> 3.2.0)
+      rspec-expectations (~> 3.2.0)
+      rspec-mocks (~> 3.2.0)
+    rspec-core (3.2.3)
+      rspec-support (~> 3.2.0)
+    rspec-expectations (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-mocks (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.2)
+    simplecov (0.10.0)
+      docile (~> 1.1.0)
+      json (~> 1.8)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
+    yard (0.8.7.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  byebug
+  msfl (~> 1.1)
+  rspec
+  simplecov
+  yard

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Referly
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,64 @@
+[![Circle CI](https://circleci.com/gh/Referly/msfl_visitors.svg?style=svg)](https://circleci.com/gh/Referly/msfl-visitors)
+
+# msfl_visitors
+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'
+
+ filter = { make: "Toyota" }
+
+ collector = String.new
+
+ renderer = MSFLVisitors::Renderers::Chewy::TermFilter.new
+
+ visitor = MSFLVisitors::Visitor.new collector, renderer
+
+ MSFLVisitors::AST.new(filter).accept(visitor)
+
+ => 'make == "Toyota"'
+
+ ```
+
+## Architecture
+
+msfl_visitors is designed to consume normalized Mattermark Semantic Filter Language (NMSFL).
+msfl_visitors implements a parser (parsers/msfl_parser) that converts NMSFL into an AST.
+msfl_visitors implements a visitor that traverses the ast and produces the well formed output.
+The behavior of the visitor is controlled through composition at construction. It accepts a collector and a renderer.
+
+## MSFLParser
+
+The parser accepts a Hash containing NMSFL and produces an AST.
+The parser uses a simplified version of the visitor pattern to traverse the NMSFL and produce the AST.
+
+Typically one does not interact with the parser directly, instead a consumer of this gem should interact with the AST.
+
+## AST
+
+The abstract syntax tree that represents a certain query filter. In the version of the visitor pattern herein
+adopted, each node of the AST is responsible for managing its state and traversal of itself and children.
+
+A consumer of this gem creates a new AST instance passing in a Hash of NMSFL. The AST will leverage the MSFL parser
+to construct itself. The AST object is a Node as it implements the #accept(visitor) method.
+
+## visitor
+
+Unlike the classical visitor pattern double dispatch is not strictly achieved through type matching in the visitor.
+Instead the visitor is just a single service that is composed of a collector and a renderer.
+The double dispatch is codified inside of a renderer, which like the visitors in the classic pattern can produce
+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 (<<)
+
+## 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

data/Rakefile

@@ -0,0 +1,10 @@
+require "rake"
+require 'rspec/core/rake_task'
+
+task default: [:spec] do
+  ENV['RACK_ENV'] = 'test'
+end
+
+task :spec do
+  RSpec::Core::RakeTask.new(:spec)
+end

data/circle.yml

@@ -0,0 +1,9 @@
+machine:
+
+  timezone:
+    America/Los_Angeles # Set the timezone
+
+  # Version of ruby to use
+  ruby:
+    version:
+      2.1.3

data/lib/msfl_visitors.rb

@@ -0,0 +1,7 @@
+require_relative 'msfl_visitors/ast'
+require_relative 'msfl_visitors/visitors/base'
+require_relative 'msfl_visitors/nodes'
+require_relative 'msfl_visitors/visitors/chewy_term_filter'
+require_relative 'msfl_visitors/parsers/msfl_parser'
+module MSFLVisitors
+end

data/lib/msfl_visitors/ast.rb

@@ -0,0 +1,15 @@
+module MSFLVisitors
+  class AST
+
+    attr_accessor :root
+
+    def initialize(msfl)
+      self.root = MSFLVisitors::Parsers::MSFLParser.parse msfl
+    end
+
+    # Use this method to walk the AST with a particular visitor
+    def accept(visitor)
+      root.accept visitor
+    end
+  end
+end

data/lib/msfl_visitors/nodes.rb

@@ -0,0 +1,26 @@
+# Using alphabetical order to keep these organized
+require_relative 'nodes/and'
+require_relative 'nodes/base'
+require_relative 'nodes/binary'
+require_relative 'nodes/boolean'
+require_relative 'nodes/comparison'
+require_relative 'nodes/constant_value'
+require_relative 'nodes/date'
+require_relative 'nodes/date_time'
+require_relative 'nodes/equal'
+require_relative 'nodes/filter'
+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/number'
+require_relative 'nodes/range_value'
+require_relative 'nodes/time'
+require_relative 'nodes/value'
+require_relative 'nodes/word'
+
+
+

data/lib/msfl_visitors/nodes/and.rb

@@ -0,0 +1,13 @@
+require_relative 'binary'
+module MSFLVisitors
+  module Nodes
+    class And < Binary
+
+      def accept(visitor)
+        MSFLVisitors::Nodes::Grouping::Grouping.new(left).accept visitor
+        visitor.visit self
+        MSFLVisitors::Nodes::Grouping::Grouping.new(right).accept visitor
+      end
+    end
+  end
+end

data/lib/msfl_visitors/nodes/base.rb

@@ -0,0 +1,7 @@
+module MSFLVisitors
+  module Nodes
+    class Base
+
+    end
+  end
+end

data/lib/msfl_visitors/nodes/binary.rb

@@ -0,0 +1,26 @@
+require_relative 'base'
+module MSFLVisitors
+  module Nodes
+    class Binary < Base
+
+      attr_accessor :left, :right
+
+      def accept(visitor)
+        visitor.visit left
+        visitor.visit self
+        visitor.visit right
+      end
+
+      def initialize(left, right)
+        self.left = left
+        self.right = right
+      end
+
+      def ==(other)
+        self.class == other.class &&
+            self.left == other.left &&
+            self.right == other.right
+      end
+    end
+  end
+end

data/lib/msfl_visitors/nodes/boolean.rb

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

data/lib/msfl_visitors/nodes/comparison.rb

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

data/lib/msfl_visitors/nodes/constant_value.rb

@@ -0,0 +1,11 @@
+require_relative 'base'
+module MSFLVisitors
+  module Nodes
+    class ConstantValue < Base
+
+      def accept(visitor)
+        visitor.visit self
+      end
+    end
+  end
+end

data/lib/msfl_visitors/nodes/date.rb

@@ -0,0 +1,7 @@
+require_relative 'range_value'
+module MSFLVisitors
+  module Nodes
+    class Date < RangeValue
+    end
+  end
+end

data/lib/msfl_visitors/nodes/date_time.rb

@@ -0,0 +1,7 @@
+require_relative 'range_value'
+module MSFLVisitors
+  module Nodes
+    class DateTime < RangeValue
+    end
+  end
+end

data/lib/msfl_visitors/nodes/equal.rb

@@ -0,0 +1,7 @@
+require_relative 'comparison'
+module MSFLVisitors
+  module Nodes
+    class Equal < Comparison
+    end
+  end
+end

data/lib/msfl_visitors/nodes/filter.rb

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

data/lib/msfl_visitors/nodes/greater_than.rb

@@ -0,0 +1,7 @@
+require_relative 'comparison'
+module MSFLVisitors
+  module Nodes
+    class GreaterThan < Comparison
+    end
+  end
+end

data/lib/msfl_visitors/nodes/greater_than_equal.rb

@@ -0,0 +1,7 @@
+require_relative 'comparison'
+module MSFLVisitors
+  module Nodes
+    class GreaterThanEqual < Comparison
+    end
+  end
+end

data/lib/msfl_visitors/nodes/grouping/close.rb

@@ -0,0 +1,9 @@
+require_relative '../constant_value'
+module MSFLVisitors
+  module Nodes
+    module Grouping
+      class Close < ConstantValue
+      end
+    end
+  end
+end

data/lib/msfl_visitors/nodes/grouping/grouping.rb

@@ -0,0 +1,24 @@
+require_relative '../base'
+require_relative 'close'
+require_relative 'open'
+module MSFLVisitors
+  module Nodes
+    module Grouping
+      class Grouping < Base
+
+        attr_accessor :contents
+
+        def accept(visitor)
+          Open.new.accept visitor
+          contents.accept visitor
+          Close.new.accept visitor
+        end
+
+        # @param node [MSFL::Nodes::Base] the node that the grouping surrounds
+        def initialize(node)
+          self.contents = node
+        end
+      end
+    end
+  end
+end

data/lib/msfl_visitors/nodes/grouping/open.rb

@@ -0,0 +1,9 @@
+require_relative '../constant_value'
+module MSFLVisitors
+  module Nodes
+    module Grouping
+      class Open < ConstantValue
+      end
+    end
+  end
+end

data/lib/msfl_visitors/nodes/less_than.rb

@@ -0,0 +1,7 @@
+require_relative 'comparison'
+module MSFLVisitors
+  module Nodes
+    class LessThan < Comparison
+    end
+  end
+end

data/lib/msfl_visitors/nodes/less_than_equal.rb

@@ -0,0 +1,7 @@
+require_relative 'comparison'
+module MSFLVisitors
+  module Nodes
+    class LessThanEqual < Comparison
+    end
+  end
+end

data/lib/msfl_visitors/nodes/number.rb

@@ -0,0 +1,7 @@
+require_relative 'range_value'
+module MSFLVisitors
+  module Nodes
+    class Number < RangeValue
+    end
+  end
+end

data/lib/msfl_visitors/nodes/range_value.rb

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

data/lib/msfl_visitors/nodes/time.rb

@@ -0,0 +1,7 @@
+require_relative 'range_value'
+module MSFLVisitors
+  module Nodes
+    class Time < RangeValue
+    end
+  end
+end

data/lib/msfl_visitors/nodes/value.rb

@@ -0,0 +1,22 @@
+require_relative 'base'
+module MSFLVisitors
+  module Nodes
+    class Value < Base
+
+      attr_accessor :value
+
+      def accept(visitor)
+        visitor.visit self
+      end
+
+      def initialize(expr)
+        self.value = expr
+      end
+
+      def ==(other)
+        self.class == other.class &&
+          value == other.value
+      end
+    end
+  end
+end

data/lib/msfl_visitors/nodes/word.rb

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

data/lib/msfl_visitors/parsers/msfl_parser.rb

@@ -0,0 +1,78 @@
+require 'msfl'
+module MSFLVisitors
+  module Parsers
+    class MSFLParser
+      include MSFL::Validators::Definitions::HashKey
+
+      def parse(obj, lhs = false)
+        # send("parse_#{obj.class.to_s.gsub('::', '_')}", obj, lhs)
+        case obj
+
+          when Float, Fixnum
+            MSFLVisitors::Nodes::Number.new obj
+
+          when Hash
+            parse_Hash obj, lhs
+
+          when MSFL::Types::Set
+            parse_Set obj, lhs
+
+          when Symbol, String, NilClass
+            MSFLVisitors::Nodes::Word.new obj.to_s
+
+          else
+            fail ArgumentError, "Invalid NMSFL, unable to parse."
+        end
+      end
+
+
+
+
+    private
+
+      def parse_Hash(obj, lhs = false)
+        nodes = Array.new
+        obj.each do |k, v|
+          nodes << hash_dispatch(k, v, lhs)
+        end
+        MSFLVisitors::Nodes::Filter.new nodes
+      end
+
+      def parse_Set(obj, lhs = false)
+        fail NoMethodError, "#parse_Set is not yet implemented."
+      end
+
+      def hash_dispatch(key, value, lhs = false)
+        if hash_key_operators.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)]
+          Object.const_get("MSFLVisitors::Nodes::#{key.to_s.capitalize}").new(*args)
+        else
+          # the key is a field
+          # there are three possible scenarios when they key is a field
+          # 1. the implicit equality scenario, where the right side is a value
+          #     { make: "toyota" }
+          #
+          # 2. the explicit comparison scenario
+          #     { value: { gte: 2000 } }
+          #
+          # 3. the containment scenario
+          #     { model: { in: ["Corolla", "Civic", "Mustang"] } }
+          #
+          # 2 & 3 are just hashes and can be parsed using the same method
+          lhs = MSFLVisitors::Nodes::Word.new key
+
+          # the node type generated by parsing value can use the lhs node when appropriate and otherwise ignore it
+          # although I can't think of a situation when it would ignore it.
+          rhs = parse value, lhs
+          if rhs.is_a? MSFLVisitors::Nodes::Value
+            MSFLVisitors::Nodes::Equal.new lhs, rhs
+          else
+            rhs
+          end
+        end
+      end
+    end
+  end
+end

data/lib/msfl_visitors/visitors/base.rb

@@ -0,0 +1,15 @@
+module MSFLVisitors
+  module Visitors
+    class Base
+      attr_accessor :collector
+
+      def visit(obj)
+        send("visit_#{obj.class.to_s.gsub('::', '_')}", obj, collector)
+      end
+
+      def initialize(collector)
+        self.collector = collector
+      end
+    end
+  end
+end

data/lib/msfl_visitors/visitors/chewy_term_filter.rb

@@ -0,0 +1,70 @@
+module MSFLVisitors
+  module Visitors
+    class ChewyTermFilter < Base
+
+      # Instead of using string interpolation only supported operators are enabled
+      BINARY_OPERATORS = { eq: "==", gt: ">", gte: ">=", lt: "<", lte: "<=", and: "&" }
+
+      def visit_MSFLVisitors_Nodes_And(obj, collector)
+        binary_helper :and, collector
+      end
+
+      def visit_MSFLVisitors_Nodes_Boolean(obj, collector)
+        collector << obj.value
+      end
+
+      def visit_MSFLVisitors_Nodes_Date(obj, collector)
+        collector << obj.value.iso8601
+      end
+
+      def visit_MSFLVisitors_Nodes_DateTime(obj, collector)
+        collector << obj.value.iso8601
+      end
+
+      def visit_MSFLVisitors_Nodes_Equal(obj, collector)
+        binary_helper :eq, collector
+      end
+
+      def visit_MSFLVisitors_Nodes_GreaterThan(obj, collector)
+        binary_helper :gt, collector
+      end
+
+      def visit_MSFLVisitors_Nodes_GreaterThanEqual(obj, collector)
+        binary_helper :gte, collector
+      end
+
+      def visit_MSFLVisitors_Nodes_Grouping_Close(obj, collector)
+        collector << " )"
+      end
+
+      def visit_MSFLVisitors_Nodes_Grouping_Open(obj, collector)
+        collector << "( "
+      end
+
+      def visit_MSFLVisitors_Nodes_LessThan(obj, collector)
+        binary_helper :lt, collector
+      end
+
+      def visit_MSFLVisitors_Nodes_LessThanEqual(obj, collector)
+        binary_helper :lte, collector
+      end
+
+      def visit_MSFLVisitors_Nodes_Number(obj, collector)
+        collector << obj.value
+      end
+
+      def visit_MSFLVisitors_Nodes_Time(obj, collector)
+        collector << obj.value.iso8601
+      end
+
+      def visit_MSFLVisitors_Nodes_Word(obj, collector)
+        collector << "#{obj.value.to_s}"
+      end
+
+    private
+      def binary_helper(operator, collector)
+        collector << " #{BINARY_OPERATORS.fetch(operator.to_sym)} "
+      end
+    end
+  end
+end

data/msfl_visitors.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |s|
+  s.name        = 'msfl_visitors'
+  s.version     = '0.0.1'
+  s.date        = '2015-05-01'
+  s.summary     = "Convert MSFL to other forms"
+  s.description = "Visitor pattern approach to converting MSFL to other forms."
+  s.authors     = ["Courtland Caldwell"]
+  s.email       = 'courtland@mattermark.com'
+  s.files         = `git ls-files`.split("\n")
+  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_development_dependency "rake", "~> 10.3"
+  s.add_development_dependency "simplecov", "~> 0.10"
+  s.add_development_dependency "yard", "~> 0.8"
+  s.add_development_dependency "rspec", "~> 3.2"
+  s.add_development_dependency "byebug", "~> 4.0"
+  s.license     = "MIT"
+end

data/simplecov_custom_profiles.rb

@@ -0,0 +1,5 @@
+require 'simplecov'
+SimpleCov.profiles.define 'msfl-visitors' do
+  add_filter '/spec'
+  add_filter '/test'
+end

data/spec/parsers/parse_msfl_spec.rb

@@ -0,0 +1,22 @@
+# This is a working file until I split these up
+require 'spec_helper'
+
+describe MSFLVisitors::Parsers::MSFLParser do
+
+   describe "parsing a trivial filter" do
+
+     subject { described_class.new.parse msfl }
+
+     let(:msfl) { { make: "Ferrari" } }
+
+     let(:expected) { MSFLVisitors::Nodes::Filter.new [ MSFLVisitors::Nodes::Equal.new(left, right) ] }
+
+     let(:left) { MSFLVisitors::Nodes::Word.new :make }
+
+     let(:right) { MSFLVisitors::Nodes::Word.new "Ferrari" }
+
+     it "is the expected AST" do
+       expect(subject).to eq expected
+     end
+   end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require_relative '../simplecov_custom_profiles'
+SimpleCov.start 'msfl-visitors'
+require 'rspec/support/spec'
+require 'byebug'
+require 'msfl_visitors'

data/spec/visitors/chewy_term_filter/visit_binary_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe MSFLVisitors::Visitors::ChewyTermFilter do
+
+  subject { node.accept visitor }
+
+  let(:node) { fail ArgumentError, "You must define the node variable in each scope." }
+
+  let(:visitor) { described_class.new collector }
+
+  let(:collector) { String.new }
+
+  let(:left) { MSFLVisitors::Nodes::Word.new "lhs" }
+
+  let(:right) { MSFLVisitors::Nodes::Word.new "rhs" }
+
+  describe "visiting an And node" do
+
+    let(:node) { MSFLVisitors::Nodes::And.new left, right }
+
+    it "matches ( left ) & ( right )" do
+      expect(subject).to match "( lhs ) & ( rhs )"
+    end
+  end
+
+end

data/spec/visitors/chewy_term_filter/visit_comparison_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe MSFLVisitors::Visitors::ChewyTermFilter do
+
+  subject { node.accept visitor }
+
+  let(:node) { fail ArgumentError, "You must define the node variable in each scope." }
+
+  let(:visitor) { described_class.new collector }
+
+  let(:collector) { String.new }
+
+  let(:left) { MSFLVisitors::Nodes::Word.new "lhs" }
+
+  let(:right) { MSFLVisitors::Nodes::Word.new "rhs" }
+
+  describe "visiting an Equal node" do
+
+    let(:node) { MSFLVisitors::Nodes::Equal.new left, right }
+
+    it "matches left == right" do
+      expect(subject).to match "lhs == rhs"
+    end
+  end
+
+  describe "visiting a GreaterThan node" do
+
+    let(:node) { MSFLVisitors::Nodes::GreaterThan.new left, right }
+
+    it "matches left > right" do
+      expect(subject).to match "lhs > rhs"
+    end
+  end
+
+  describe "visiting a GreaterThanEqual node" do
+
+    let(:node) { MSFLVisitors::Nodes::GreaterThanEqual.new left, right }
+
+    it "matches left >= right" do
+      expect(subject).to match "lhs >= rhs"
+    end
+  end
+
+  describe "visiting a LessThan node" do
+
+    let(:node) { MSFLVisitors::Nodes::LessThan.new left, right }
+
+    it "matches left < right" do
+      expect(subject).to match "lhs < rhs"
+    end
+  end
+
+  describe "visiting a LessThanEqual node" do
+
+    let(:node) { MSFLVisitors::Nodes::LessThanEqual.new left, right }
+
+    it "matches left <= right" do
+      expect(subject).to match "lhs <= rhs"
+    end
+  end
+end

data/spec/visitors/chewy_term_filter/visit_range_value_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe MSFLVisitors::Visitors::ChewyTermFilter do
+
+  subject { node.accept visitor }
+
+  let(:node) { fail ArgumentError, "You must define the node variable in each scope." }
+
+  let(:visitor) { described_class.new collector }
+
+  let(:collector) { Array.new }
+
+  describe "visiting a Date node" do
+
+    let(:node) { MSFLVisitors::Nodes::Date.new Date.today }
+
+    it "is today's date using iso8601 formatting" do
+      expect(subject.first).to eq Date.today.iso8601
+    end
+  end
+
+  describe "visiting a DateTime node" do
+
+    let(:now) { DateTime.now }
+
+    let(:node) { MSFLVisitors::Nodes::DateTime.new now }
+
+    it "is the current date and time using iso8601 formatting" do
+      expect(subject.first).to eq now.iso8601
+    end
+  end
+
+  describe "visiting a Number node" do
+
+    let(:node) { MSFLVisitors::Nodes::Number.new number }
+
+    let(:number) { 123 }
+
+    it "is the number" do
+      expect(subject.first).to eq number
+    end
+
+    context "when the number is a float" do
+
+      let(:number) { 123.456 }
+
+      it "is the number with the same precision" do
+        expect(subject.first).to eq number
+      end
+    end
+  end
+
+  describe "visiting a Time node" do
+
+    let(:node) { MSFLVisitors::Nodes::Time.new current_time }
+
+    let(:current_time) { Time.now }
+
+    it "is the current time using iso8601 formatting" do
+      expect(subject.first).to eq current_time.iso8601
+    end
+  end
+end

data/spec/visitors/chewy_term_filter/visit_value_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe MSFLVisitors::Visitors::ChewyTermFilter do
+
+  subject { node.accept visitor }
+
+  let(:node) { fail ArgumentError, "You must define the node variable in each scope." }
+
+  let(:visitor) { described_class.new collector }
+
+  let(:collector) { Array.new }
+
+  describe "visiting a Boolean node" do
+
+    let(:node) { MSFLVisitors::Nodes::Boolean.new value }
+
+    context "when the node has a value of true" do
+
+      let(:value) { true }
+
+      it "is true" do
+        expect(subject.first).to be true
+      end
+    end
+
+    context "when the node has a value of false" do
+
+      let(:value) { false }
+
+      it "is false" do
+        expect(subject.first).to be false
+      end
+    end
+  end
+
+  describe "visiting a Word node" do
+
+    let(:node) { MSFLVisitors::Nodes::Word.new "node_content" }
+
+    it "is a literal string" do
+      expect(subject.first).to match /node_content/
+    end
+  end
+end

metadata

@@ -0,0 +1,183 @@
+--- !ruby/object:Gem::Specification
+name: msfl_visitors
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Courtland Caldwell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: msfl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.6
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: Visitor pattern approach to converting MSFL to other forms.
+email: courtland@mattermark.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- circle.yml
+- lib/msfl_visitors.rb
+- lib/msfl_visitors/ast.rb
+- lib/msfl_visitors/nodes.rb
+- lib/msfl_visitors/nodes/and.rb
+- lib/msfl_visitors/nodes/base.rb
+- lib/msfl_visitors/nodes/binary.rb
+- lib/msfl_visitors/nodes/boolean.rb
+- lib/msfl_visitors/nodes/comparison.rb
+- lib/msfl_visitors/nodes/constant_value.rb
+- lib/msfl_visitors/nodes/date.rb
+- lib/msfl_visitors/nodes/date_time.rb
+- lib/msfl_visitors/nodes/equal.rb
+- lib/msfl_visitors/nodes/filter.rb
+- lib/msfl_visitors/nodes/greater_than.rb
+- lib/msfl_visitors/nodes/greater_than_equal.rb
+- lib/msfl_visitors/nodes/grouping/close.rb
+- lib/msfl_visitors/nodes/grouping/grouping.rb
+- lib/msfl_visitors/nodes/grouping/open.rb
+- lib/msfl_visitors/nodes/less_than.rb
+- lib/msfl_visitors/nodes/less_than_equal.rb
+- lib/msfl_visitors/nodes/number.rb
+- lib/msfl_visitors/nodes/range_value.rb
+- lib/msfl_visitors/nodes/time.rb
+- lib/msfl_visitors/nodes/value.rb
+- lib/msfl_visitors/nodes/word.rb
+- lib/msfl_visitors/parsers/msfl_parser.rb
+- lib/msfl_visitors/visitors/base.rb
+- lib/msfl_visitors/visitors/chewy_term_filter.rb
+- msfl_visitors.gemspec
+- simplecov_custom_profiles.rb
+- spec/parsers/parse_msfl_spec.rb
+- spec/spec_helper.rb
+- spec/visitors/chewy_term_filter/visit_binary_spec.rb
+- spec/visitors/chewy_term_filter/visit_comparison_spec.rb
+- spec/visitors/chewy_term_filter/visit_range_value_spec.rb
+- spec/visitors/chewy_term_filter/visit_value_spec.rb
+homepage: https://github.com/Referly/msfl_visitors
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Convert MSFL to other forms
+test_files:
+- spec/parsers/parse_msfl_spec.rb
+- spec/spec_helper.rb
+- spec/visitors/chewy_term_filter/visit_binary_spec.rb
+- spec/visitors/chewy_term_filter/visit_comparison_spec.rb
+- spec/visitors/chewy_term_filter/visit_range_value_spec.rb
+- spec/visitors/chewy_term_filter/visit_value_spec.rb
+has_rdoc: