querylet 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6eae3b4c9cb1beeea8edfbb41bab195ad133ac2c91d6393942f942d075860324
+  data.tar.gz: 6632e474232ac27c6e64cd3d991b65e5331e61e97116280b9b8a9b00c1702a5f
+SHA512:
+  metadata.gz: c33031f332be7c159ce11f3fb4ec86cf8b606125ad3cf51cfd28c4aa7bb3600d2d5188b7bcb91664bc7b00d307cd258784b09fed852e5886cc8cd4e243ea22d6
+  data.tar.gz: 1d5b1e8f732f7dd43dd110c442528a5af5b6d9939593d57bb5a9f5724e2e9d8fab9083265a885f2e57977f6612724babdc3a451aa0c786b0c4f7ab0edca19c30

data/README.md

@@ -0,0 +1,76 @@
+## Querylet
+
+#Variables
+
+{{my_variable}}
+
+#Partials
+
+{{>include 'link.to.path' param='{{testing}}'}}
+
+#Partial blocks
+{{#array}}
+{{/array}}
+
+# If Else
+{{#if variable}}
+{{else}}
+{{/end}}
+
+## Parslet
+
+https://www.youtube.com/watch?time_continue=873&v=ET_POMJNWNs&feature=emb_title
+https://kschiess.github.io/parslet/parser.html
+https://www.rubydoc.info/github/kschiess/parslet/Parslet/Atoms/Scope
+
+https://www.rubydoc.info/github/kschiess/parslet/Parslet/Atoms/Capture
+
+# Extra input after last repetition
+https://stackoverflow.com/questions/27095141/how-do-i-get-my-parser-atom-to-terminate-inside-a-rule-including-optional-spaces
+
+
+# Parset Slice
+
+str('Boston').parse('Boston') #=> "Boston"@0
+
+The @0 is the offset
+
+
+https://www.sitepoint.com/parsing-parslet-gem/
+
+# Parset Debugging
+
+If the parser.rb runs into errors you can add the following to help
+debug what is happening
+
+```rb
+require 'parslet/convenience'
+parser.parse_with_debug(input)
+```
+
+### How it works:
+
+* parser.rb    — Create a grammar: What should be legal syntax?
+* transform.rb — Annotate the grammar: What is important data?
+* tree.rb      - Create a transformation: How do I want to work with that data?
+
+## Parser
+
+Parslet parsers output deep nested hashes.
+
+To see all the define rules check out `parser_helper.rb`
+
+```
+rspec spec/parser_helper.rb
+```
+
+## Transform
+
+You capture patterns in your deep nested hash and the pass to a tree
+
+## Tree
+
+The tree does something with your captured patterns
+
+
+

data/lib/querylet.rb

@@ -0,0 +1,35 @@
+require_relative 'querylet/parser'
+require_relative 'querylet/transform'
+require_relative 'querylet/tree'
+require_relative 'querylet/template'
+require_relative 'querylet/context'
+
+module Querylet
+  class Querylet
+    include Context
+    def initialize(path:)
+      @sql_path = path
+    end
+
+    def compile(content)
+      parser    = Parser.new
+      transform = Transform.new
+      #puts "parser.parse"
+      deep_nested_hash = parser.parse_with_debug(content)
+      #puts deep_nested_hash
+      abstract_syntax_tree = transform.apply deep_nested_hash
+      #puts abstract_syntax_tree
+      Template.new self, abstract_syntax_tree
+    end
+
+    def set_context(ctx)
+      @data = ctx
+    end
+
+    def get_partial name, dot_path
+      path = @sql_path + '/' + dot_path.to_s.split('.').join('/') + '.sql'
+      template = File.read(path).to_s.chomp
+      self.compile(template).call(@data)
+    end
+  end # class Querylet
+end # module Querylet

data/lib/querylet/context.rb

@@ -0,0 +1,31 @@
+module Querylet
+  module Context
+    def get(value)
+      @data.merge(locals)[value.to_sym]
+    end
+
+    def add_item(key, value)
+      locals[key.to_sym] = value
+    end
+
+    def add_items(hash)
+      hash.map { |k, v| add_item(k, v) }
+    end
+
+    def with_temporary_context(args = {})
+      saved = args.keys.collect { |key| [key, get(key.to_s)] }.to_h
+
+      add_items(args)
+      block_result = yield
+      locals.merge!(saved)
+
+      block_result
+    end
+
+    private
+
+    def locals
+      @locals ||= {}
+    end
+  end
+end

data/lib/querylet/parser.rb

@@ -0,0 +1,153 @@
+require 'parslet'
+require 'parslet/convenience'
+
+module Querylet
+  class Parser < Parslet::Parser
+    # Every parser has a root. This designates where parsing should start.
+    # It is like an entry point to your parser.
+    root :document
+
+    # "|" is an Alternation which is the equivlent of an OR operator
+    # .repeat means to match repeatly the following atoms
+    rule(:document) { item.repeat.as(:items) }
+
+    rule(:item) { ifelse | block | partial | filter | variable | content }
+
+    # {{ indentifer parameter }}
+    rule(:filter) {
+      docurly >>
+      space? >>
+      id.as(:filter) >>
+      (space? >> parameter.as(:parameter)) >>
+      space? >>
+      dccurly
+    }
+
+    rule(:partial) {
+      docurly >>
+      space? >>
+      gt >>
+      space? >>
+      id.as(:partial) >>
+      space? >>
+      path >>
+      space? >>
+      (
+        parameter_kv >>
+        space?
+      ).repeat.as(:parameters) >>
+      space? >>
+      dccurly
+    }
+
+    rule(:block){
+      docurly >>
+      space? >>
+      hash >>
+      space? >>
+      id.capture(:block).as(:block) >>
+      space? >>
+      dccurly >>
+      space? >>
+      scope {
+        document
+      } >>
+      dynamic { |src, scope|
+        docurly >> space? >> slash >> space? >> str(scope.captures[:block]) >> space? >> dccurly
+      }
+    }
+
+    rule(:ifelse){
+      # {{#if variable}}
+      docurly >>
+      space? >>
+      hash >>
+      if_kw.as(:if_kind) >>
+      space? >>
+      id.as(:if_variable) >>
+      space? >>
+      dccurly >>
+
+      scope {
+        document
+      } >>
+
+      scope {
+        docurly >>
+        space? >>
+        slash >>
+        space? >>
+        else_kw >>
+        space? >>
+        dccurly >>
+        scope { document.as(:else_item) }
+      }.maybe >>
+
+      # {{/if}}
+      docurly >>
+      space? >>
+      slash >>
+      if_kw >>
+      space? >>
+      dccurly
+    }
+
+    # {{ indentifer }}
+    rule(:variable) { docurly >> space? >> id.as(:variable) >> space? >> dccurly}
+
+    # Can either be a variable or a string:
+    rule(:parameter)   { id.as(:variable) | string }
+
+    # used in includes eg. hello='world'
+    rule(:parameter_kv) {
+      id.as(:key) >> 
+      space? >>
+      eq >>
+      space? >>
+      string.as(:value) >>
+      space?
+    }
+
+    rule(:content) {
+      (
+        nocurly.repeat(1) | # A sequence of non-curlies
+        ocurly >> ccurly >> nocurly | # Open and closing curely that doesn't complete a {{}}
+        ocurly >> nocurly | # Opening curly that doesn't start a {{}}
+        ccurly            | # Closing curly that is not inside a {{}}
+        ocurly >> eof       # Opening curly that doesn't start a {{}} because it's the end
+      ).repeat(1).as(:content) 
+    }
+
+    rule(:space)       { match('\s').repeat(1) }
+    rule(:space?)      { space.maybe }
+    rule(:dot)         { str('.') }
+    rule(:gt)          { str('>')}
+    rule(:eq)          { str('=')}
+    rule(:hash)        { str('#')}
+    rule(:slash)       { str('/')}
+
+    rule(:if_kw)     { str('if') | str('unless') }
+    rule(:else_kw)     { str('else') }
+
+    # Open Curled Bracket eg. "{"
+    rule(:ocurly)      { str('{')}
+
+    # Closed Cured Bracket eg. "}"
+    rule(:ccurly)      { str('}')}
+
+    # Double Open Curled Bracked eg. "{{"
+    rule(:docurly)     { ocurly >> ocurly }
+
+    # Double Closed Curled Bracked eg. "}}"
+    rule(:dccurly)     { ccurly >> ccurly }
+
+    rule(:id)  { match['a-zA-Z0-9_'].repeat(1) }
+    rule(:path)        { match("'") >> (id >> (dot >> id).repeat).as(:path) >> match("'") }
+
+    rule(:nocurly)     { match('[^{}]') }
+    rule(:eof)         { any.absent? }
+
+    # String contained in Single Qoutes 'content'
+    rule(:string)   { match("'") >> match("[^']").repeat(1).as(:string) >> match("'") }
+  end
+end

data/lib/querylet/template.rb

@@ -0,0 +1,19 @@
+#require_relative 'context'
+
+module Querylet
+  class Template
+    def initialize(querylet, ast)
+      @querylet = querylet
+      @ast = ast
+    end
+
+    def call(args = nil)
+      if args
+        @querylet.set_context(args)
+      end
+
+      # AST should return a Querylet::Tree and call its eval method
+      @ast.eval(@querylet)
+    end
+  end
+end

data/lib/querylet/transform.rb

@@ -0,0 +1,59 @@
+require_relative 'tree'
+
+module Querylet
+  class Transform < Parslet::Transform
+    rule(content: simple(:content)) {
+      Tree::TemplateContent.new(content)
+    }
+
+    rule(variable: simple(:item)) {
+      Tree::Variable.new(item)
+    }
+
+    rule(string: simple(:content)) {
+      Tree::String.new(content)
+    }
+
+    rule(
+      if_kind: simple(:if_kind),
+      if_variable: simple(:variable),
+      items: subtree(:items),
+      else_item: subtree(:else_items)
+    ) {
+      Tree::IfElseBlock.new(if_kind, variable, items, else_items)
+    }
+
+    rule(
+      if_kind: simple(:if_kind),
+      if_variable: simple(:variable),
+      items: subtree(:items)
+    ) {
+      Tree::IfBlock.new(if_kind, variable, items)
+    }
+
+    rule(
+      partial: simple(:partial),
+      path: simple(:path),
+      parameters: subtree(:parameters),
+    ) {
+      Tree::Partial.new(partial, path, parameters)
+    }
+
+    rule(
+      filter: simple(:filter),
+      parameter: subtree(:parameter)
+    ) {
+      Tree::Filter.new(filter,parameter)
+    }
+
+    rule(
+      block: simple(:block),
+      items: subtree(:items)
+    ) {
+      Tree::Block.new(block,items)
+    }
+
+    rule(items: subtree(:items)) {Tree::Items.new(items)}
+  end
+end
+

data/lib/querylet/tree.rb

@@ -0,0 +1,171 @@
+module Querylet
+  class Tree < Parslet::Transform
+    class TreeItem < Struct
+      def eval(context)
+        _eval(context)
+      end
+    end
+
+    class TemplateContent < TreeItem.new(:content)
+      def _eval(context)
+        return content
+      end
+    end
+
+    class Variable < TreeItem.new(:item)
+      def _eval(context)
+        context.get(item)
+      end
+    end
+
+    class String < TreeItem.new(:content)
+      def _eval(context)
+        return content
+      end
+    end
+
+    class Parameter < TreeItem.new(:name)
+      def _eval(context)
+        if name.is_a?(Parslet::Slice)
+          context.get(name.to_s)
+        else
+          name._eval(context)
+        end
+      end
+    end
+
+    class Partial < TreeItem.new(:partial, :path, :parameters)
+      def _eval(context)
+        [parameters].flatten.map(&:values).map do |vals|
+          context.add_item vals.first.to_s, vals.last._eval(context)
+        end
+        content = context.get_partial(partial.to_s, path)
+        if partial == 'array'
+        <<-HEREDOC.chomp
+(SELECT COALESCE(array_to_json(array_agg(row_to_json(array_row))),'[]'::json) FROM (
+#{content}
+) array_row)
+        HEREDOC
+        elsif partial == 'object'
+        <<-HEREDOC.chomp
+(SELECT COALESCE(row_to_json(object_row),'{}'::json) FROM (
+#{content}
+) object_row)
+      HEREDOC
+        elsif partial == 'include'
+          content
+        end
+      end
+    end
+
+    class IfBlock < TreeItem.new(:if_kind, :variable, :items)
+      def _eval(context)
+        if if_kind == 'if'
+          if context.get(variable)
+            items.map {|item| item._eval(context)}.join()
+          end
+        elsif if_kind == 'unless'
+          unless context.get(variable)
+            items.map {|item| item._eval(context)}.join()
+          end
+        end
+      end
+    end
+
+    class IfElseBlock < TreeItem.new(:if_kind, :variable, :items, :else_items)
+      def _eval(context)
+        if if_kind == 'if'
+          if context.get(variable)
+            items.map {|item| item._eval(context)}.join()
+          else
+            else_items.items.map {|item| item._eval(context)}.join()
+          end
+        elsif if_kind == 'unless'
+          unless context.get(variable)
+            items.map {|item| item._eval(context)}.join()
+          else
+            else_items.items.map {|item| item._eval(context)}.join()
+          end
+        end
+      end
+    end
+
+    class Filter < TreeItem.new(:filter,:parameter)
+      def _eval(context)
+        val = context.get(parameter.item)
+        if filter == 'int'
+          if val.is_a?(Integer)
+            val.to_s
+          else
+            raise "expected input for: #{parameter.item} to be an Integer"
+          end
+        elsif filter == 'float'
+          if val.is_a?(Float)
+            val.to_s
+          else
+            raise "expected input for: #{parameter.item} to be a Float"
+          end
+        elsif filter == 'arr'
+          if val.is_a?(Array)
+            if val.all?{|a| a.class.to_s == 'String' } # to_a? was not working
+              "'#{val.join("','")}'"
+            elsif val.all?{|a| a.is_a?(Integer) }
+              val.join(',')
+            elsif val.all?{|a| a.is_a?(Float) }
+              val.join(',')
+            else
+              raise "expected input for: #{parameter.item} to be an Array with all of the same datatype eg String, Integer, Float"
+            end
+          else
+            raise "expected input for: #{parameter.item} to be an Array"
+          end
+        elsif filter == 'str'
+          if val.class.to_s == 'String' # to_a? was not working
+            "'#{val}'"
+          else
+            raise "expected input for: #{parameter.item} to be a String"
+          end
+        elsif filter == 'wild'
+          if val.class.to_s == 'String' || val.is_a?(Integer) || val.is_a?(Float)
+            "'%#{val}%'"
+          else
+            raise "expected input for: #{parameter.item} to be String, Integer or Array"
+          end
+        end
+      end
+    end
+
+    class Block < TreeItem.new(:block,:items)
+      def _eval(context)
+        content = items.map {|item| item._eval(context)}.join()
+        if block == 'array'
+        <<-HEREDOC.chomp
+(SELECT COALESCE(array_to_json(array_agg(row_to_json(array_row))),'[]'::json) FROM (
+#{content}
+) array_row)
+      HEREDOC
+        elsif block == 'object'
+        <<-HEREDOC.chomp
+(SELECT COALESCE(row_to_json(object_row),'{}'::json) FROM (
+#{content}
+) object_row)
+      HEREDOC
+        else
+          content
+        end
+      end
+    end
+
+    class Items < TreeItem.new(:items)
+      def _eval(context)
+        items.map {|item| item._eval(context)}.join()
+      end
+      alias :fn :_eval
+
+      def add_item(i)
+        items << i
+      end
+    end
+
+  end
+end

data/lib/querylet/version.rb

@@ -0,0 +1,4 @@
+module Querylet
+  VERSION = "1.0.0"
+end
+

data/spec/parser_spec.rb

@@ -0,0 +1,82 @@
+require_relative '../lib/querylet/parser'
+require 'pry'
+
+RSpec.describe Querylet::Parser do
+  let(:parser) {Querylet::Parser.new() }
+
+  context 'recognizes' do
+    it 'content' do
+      expect(parser.parse('Deep Space Nine')).to eq({items:[{content: 'Deep Space Nine'}]})
+    end
+
+    it 'string' do 
+      (SELECT COALESCE(row_to_json(object_row),'{}'::json) FROM (
+
+      expect(parser.parse_with_debug("(SELECT COALESCE(row_to_json(object_row),'{}'::json) FROM (")).to eq({items:[{content: "(SELECT COALESCE(row_to_json(object_row),'{}'::json) FROM ("}]})
+    end
+    it 'variable' do
+      expect(parser.parse('{{worf}}')).to eq({items:[{variable: 'worf'}]})
+      expect(parser.parse('{{ worf}}')).to eq({items:[{variable: 'worf'}]})
+      expect(parser.parse('{{worf }}')).to eq({items:[{variable: 'worf'}]})
+      expect(parser.parse('{{ worf }}')).to eq({items:[{variable: 'worf'}]})
+    end
+
+    it 'filter' do
+      expect(parser.parse('{{ quote worf }}')).to eq({items:[{
+        filter: 'quote',
+        parameter: {variable: 'worf'}
+      }]})
+
+      expect(parser.parse("{{ quote 'worf' }}")).to eq({items:[{
+        filter: 'quote',
+        parameter: {string: 'worf'}
+      }]})
+    end
+
+    it 'partial' do
+      expect(parser.parse("{{> include 'path.to.template' }}")).to eq({items:[{
+        partial: 'include',
+        path: 'path.to.template',
+        parameters: []
+      }]})
+
+      expect(parser.parse("{{> include 'path.to.template' hello='world'}}")).to eq({items:[{
+        partial: 'include',
+        path: 'path.to.template',
+        parameters: [
+          {key: 'hello', value: {string: 'world'}}
+        ]
+      }]})
+
+      expect(parser.parse("{{> include 'path.to.template' hello='world' star='trek' }}")).to eq({items:[{
+        partial: 'include',
+        path: 'path.to.template',
+        parameters: [
+          {key: 'hello', value: {string: 'world'}},
+          {key: 'star', value: {string: 'trek'}}
+        ]
+      }]})
+    end
+
+    it 'block' do
+      results = parser.parse("{{#object}}this is a test{{/object}}")
+      expect(results).to eq({items:[
+        { block: 'object', items: [{ content: 'this is a test' }] }
+      ]})
+    end
+
+    it 'if' do
+      results = parser.parse("{{#if hello}} this is true {{/if}}")
+      expect(results).to eq(
+        {:items=>[{:if_kind=>"if", :if_variable=>"hello", :items=>[{:content=>" this is true "}]}]}
+      )
+    end
+
+    it 'ifelse' do
+      results = parser.parse_with_debug("{{#unless hello}}true{{/else}}false{{/if}}")
+      expect(results).to eq(
+       {:items=>[{:else_item=>{:items=>[{:content=>"false"}]}, :if_kind=>"unless", :if_variable=>"hello", :items=>[{:content=>"true"}]}]}
+      )
+    end
+  end # context 'recognizes' do
+end

data/spec/querylet_spec.rb

@@ -0,0 +1,156 @@
+require_relative '../lib/querylet'
+require 'pry'
+
+describe Querylet::Querylet do
+  let(:querylet) {Querylet::Querylet.new path: File.expand_path('./') }
+
+  def evaluate(template, data = {})
+    querylet.compile(template).call(data)
+  end
+
+  context 'evaluating' do
+    it 'a dummy template' do
+      expect(evaluate('My simple template')).to eq('My simple template')
+    end
+
+    it 'a simple replacement' do
+      expect(evaluate('Hello {{name}}', {name: 'world'})).to eq('Hello world')
+    end
+
+    it 'a double braces replacement with nil' do
+      expect(evaluate('Hello {{name}}', {name: nil})).to eq('Hello ')
+    end
+
+    context 'helpers' do
+      it 'include' do
+query = <<-SQL.chomp
+(SELECT
+  users.email
+FROM users
+WHERE
+  users.id = 1) as email
+SQL
+        expect(evaluate("({{> include 'examples.include' }}) as email")).to eq(query)
+      end
+
+      it 'include with variables' do
+query = <<-SQL.chomp
+(SELECT
+  users.email
+FROM users
+WHERE
+  users.id = 100) as email
+SQL
+        template = "({{> include 'examples.include_with_vars' }}) as email"
+        expect(evaluate(template, {id: 100})).to eq(query)
+      end
+
+      it 'include with parameters' do
+query = <<-SQL.chomp
+(SELECT
+  users.email,
+  'andrew' as name
+FROM users
+WHERE
+  users.id = 200) as email
+SQL
+        template = "({{> include 'examples.include_with_params' id='200' name='andrew' }}) as email"
+        expect(evaluate(template, {id: 100})).to eq(query)
+      end
+
+      it 'object' do
+query = <<-SQL.chomp
+(SELECT COALESCE(row_to_json(object_row),'{}'::json) FROM (
+SELECT
+  users.id,
+  users.email
+FROM users
+WHERE
+  users.id = 1
+) object_row) as user
+SQL
+        output = evaluate("{{> object 'examples.object' }} as user")
+        expect(output).to eq(query)
+      end
+
+      it 'array' do
+query = <<-SQL.chomp
+(SELECT COALESCE(array_to_json(array_agg(row_to_json(array_row))),'[]'::json) FROM (
+SELECT
+  users.id,
+  users.email
+FROM users
+) array_row) as users
+SQL
+        output = evaluate("{{> array 'examples.array' }} as users")
+        expect(output).to eq(query)
+      end
+
+      it 'if block' do
+        template = "{{#if user_id }}yes{{/if}}"
+        expect(evaluate(template, {user_id: true})).to eq('yes')
+      end
+
+      it 'unless block' do
+        template = "{{#unless user_id }}yes{{/unless}}"
+        expect(evaluate(template, {user_id: nil})).to eq('yes')
+      end
+
+      it 'if else block' do
+        template = "{{#if user_id }}yes{{/else}}no{{/if}}"
+        expect(evaluate(template, {user_id: false})).to eq('no')
+      end
+
+      it 'array block' do
+query = <<-SQL.chomp
+(SELECT COALESCE(array_to_json(array_agg(row_to_json(array_row))),'[]'::json) FROM (
+yes
+) array_row)
+SQL
+        template = "{{#array}}yes{{/array}}"
+        expect(evaluate(template)).to eq(query)
+      end
+
+      it 'object block' do
+query = <<-SQL.chomp
+(SELECT COALESCE(row_to_json(object_row),'{}'::json) FROM (
+yes
+) object_row)
+SQL
+        template = "{{#object}}yes{{/object}}"
+        expect(evaluate(template)).to eq(query)
+      end
+
+      it 'int filter' do
+        template = "{{int user_id}}"
+        expect(evaluate(template,{user_id: 2})).to eq('2')
+      end
+
+      it 'float filter' do
+        template = "{{float user_id}}"
+        expect(evaluate(template,{user_id: 2.2})).to eq('2.2')
+      end
+
+      it 'arr filter' do
+        template = "{{arr ids}}"
+        expect(evaluate(template,{ids: [1,2,3,4,5]})).to eq("1,2,3,4,5")
+      end
+
+      it 'arr filter' do
+        template = "{{arr values}}"
+        expect(evaluate(template,{values: ['hello','world']})).to eq("'hello','world'")
+      end
+
+      it 'str filter' do
+        template = "{{str world}}"
+        expect(evaluate(template,world: 'banana')).to eq("'banana'")
+      end
+
+      it 'wildcard filter' do
+        template = "{{wild email}}"
+        expect(evaluate(template,{email: 'andrew@exampro.co'})).to eq("'%andrew@exampro.co%'")
+      end
+
+    end # context 'helpers'
+  end # context 'evaluating'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,100 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: querylet
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- ExamPro
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-12-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Querylet
+email:
+- andrew@exampro.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/querylet.rb
+- lib/querylet/context.rb
+- lib/querylet/parser.rb
+- lib/querylet/template.rb
+- lib/querylet/transform.rb
+- lib/querylet/tree.rb
+- lib/querylet/version.rb
+- spec/parser_spec.rb
+- spec/querylet_spec.rb
+- spec/spec_helper.rb
+homepage: http://exampro.co
+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: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: Querylet
+test_files:
+- spec/spec_helper.rb
+- spec/parser_spec.rb
+- spec/querylet_spec.rb