rql_parser 0.0.1alpha4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75d3efb4c2d93963bc05ad192108c57e964d3224b11d5bf0291bd69a2f652ffe
-  data.tar.gz: 99270a824bf63557ce93e29b1db68491f971c5189119b8431356b0cb2444cafc
+  metadata.gz: 3ee91e4a5b5797d766aaa0bd4f5f82160a81185f135f0b2f1ca6ad1a3e744531
+  data.tar.gz: fc194c4a5a716976196c256b64c7120f488043a6eee80045f853a944d1580a56
 SHA512:
-  metadata.gz: 7598c3cd3007ac838fce30b144f0a3c181313a95855496697d538efbb608b9096779d8a06f6ea2d2fbece42128c65ac4a70aec9b39e6d6cfb8fe3603b079500b
-  data.tar.gz: acc40e93395fcbd2012fa7961c291d46bee87eaa75969155f0cfa8797cca99f94fe9a0c1a25e4d5955148acfba0bcd591dbf86a47222bd8bc78201290da38643
+  metadata.gz: 1f6e94f69597fad8bf30bc36afb5f17fdbece5b048773796d6d83bf9f2dcd6bd906468fb786c9e202d85b2fa5bf66244f5d56f981750ae3f9f90988d38069f77
+  data.tar.gz: a0e259cfa2d4ece901a93c658c26d252e0e939632e6fbd37ef61e2051b3e027bfa70e684c82950c20a754a7bfde03b709e61f9beb4ed61320fb70545630bfdc7

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+#### 1.0.0
+
+- Make function identifiers symbols instead of strings
+- Remove binary tree `group` node
+- Prettify parser code
+- Tweak grammar
+
+---
+
 #### 0.0.1alpha4
 
 - Restructure gem files

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rql_parser (0.0.1alpha3)
+    rql_parser (1.0.0)
       active_interaction (~> 3.6.0)
 
 GEM

data/README.md

@@ -10,11 +10,15 @@ gem 'rql_parser'
 
 And then execute:
 
-    $ bundle
+```
+$ bundle
+```
 
 Or install it yourself as:
 
-    $ gem install rql_parser
+```
+$ gem install rql_parser
+```
 
 ## Usage
 
@@ -23,18 +27,41 @@ See [ActiveInteraction](https://github.com/AaronLasseigne/active_interaction), a
 ```ruby
 # In controller:
 output = RqlParser.from_params(params.to_unsafe_hash)
-# To raise an error instead of returning an object:
-output = RqlParser.from_params!(params.to_unsafe_hash)
 
 # Parse RQL instead of params: 
 rql = 'eq(hello,world)&ruby=eq=awesome' # your RQL query here
 output = RqlParser.parse(rql)
-# To raise an error instead of returning an object:
-output = RqlParser.parse!(rql)
 ```
 
-`output.result` yields a binary tree representing the query.
+`output.result` yields a binary tree representing the query:
+
+```ruby
+rql = 'eq(hello,world)&ruby=eq=awesome' # your RQL query here
+output = RqlParser.parse(rql)
+output.valid?
+#=> true
+output.result
+#=> { type: :function,
+#     identifier: :and,
+#     args: [{ type: :function,
+#              identifier: :eq,
+#              args: [{ arg: 'hello' },
+#                     { arg: 'world' }] },
+#            { type: :function,
+#              identifier: :eq,
+#              args: [{ arg: 'ruby' },
+#                     { arg: 'awesome' }] }] }
+```
 
+`output.errors` yields an `ActiveModel::Errors`-like object (if any):
+```ruby
+rql = 'i=have=errors' # your invalid RQL query here
+output = RqlParser.parse(rql)
+output.valid?
+#=> false
+output.errors.full_messages
+#=> 'Rql has invalid shorthands'
+```
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/rql_parser/_grammar.ebnf

@@ -4,9 +4,9 @@ group = '(', or_exp, ')' ;
 
 or_exp = and_exp, { or_delim, and_exp } ;
 
-or_delim = '|', ';' ;
+or_delim = '|' | ';' ;
 
-and_exp = (function | and_strict | group), { ',', (function | and_strict | group) } ;
+and_exp = (function | group | and_strict), { ',', (function | group | and_strict) } ;
 
 function = identifier, '(', [arg, { ',', arg }], ')' ;
 
@@ -14,8 +14,8 @@ and_strict = (function | group), { '&', (function | group) } ;
 
 identifier = /[a-z]+/
 
-arg = and_exp | array_of_values | value ;
+arg = and_exp | arg_array | value ;
 
 value = /[_0-9a-zA-Z]+/ ;
 
-array_of_values = '(', value, { ',', value }, ')' ;
+arg_array = '(', value, { ',', value }, ')' ;

data/lib/rql_parser/base_interaction.rb

@@ -3,11 +3,11 @@ module RqlParser
   class BaseInteraction < ActiveInteraction::Base
     private
 
-    def perform(interaction)
-      if interaction.valid?
-        interaction.result
+    def perform(outcome)
+      if outcome.valid?
+        outcome.result
       else
-        errors.merge!(interaction.errors)
+        errors.merge!(outcome.errors)
       end
     end
   end

data/lib/rql_parser/services/from_params.rb

@@ -2,6 +2,7 @@
 
 module RqlParser
   module Services
+    # Creates a RQL binary tree directly from params hash
     class FromParams < BaseInteraction
       hash :params, strip: false
 

data/lib/rql_parser/services/parse.rb

@@ -1,10 +1,19 @@
-# frozen_string_literal: true
-
 module RqlParser
   module Services
+    # Service that performs the parse operation
     class Parse < BaseInteraction
       string :rql
 
+      DELIMITERS = '&,;'.freeze
+      OR_DELIMITERS = /[;|]/.freeze
+      COMMA_DELIMITER = /,/.freeze
+      AND_STRICT_DELIMITERS = /&/.freeze
+      BRACES_REGEX = /\A\(.+\)\z/.freeze
+      FUNCTION_REGEX = /\A[a-z]+\(.+\)\z/.freeze
+      FUNCTION_IDENTIFIER = /\A([a-z]+)/.freeze
+      FUNCTION_ARGS = /\A[a-z]+\((.+)\)\z/.freeze
+      VALUE_REGEX = /\A[_0-9a-zA-Z]+\z/.freeze
+
       def execute
         formatted = perform(Format.run(inputs))
         expression(formatted) || errors.add(:rql) unless errors.any?
@@ -17,101 +26,45 @@ module RqlParser
       end
 
       def group(str)
-        res = false
-        if /\A\(.+\)\z/.match?(str)
-          res = or_expression(str[1..-2])
-          if res
-            res = { type: :group, args: res } if res[:args].size > 1
-          end
-        end
-        res
+        return false unless BRACES_REGEX.match?(str)
+
+        or_expression(str[1..-2]) || false
       end
 
       def or_expression(str)
-        res = []
-        split = str.split(/[;|]/)
-        temp = ''
-        while split.any?
-          temp += split.shift
-          temp_and_exp = and_expression(temp)
-          if temp_and_exp
-            res.push(temp_and_exp)
-            temp = ''
-          else
-            temp += '|'
-          end
-        end
-        return false if temp.present?
+        result = repeat_pattern(str, OR_DELIMITERS) { |s| and_expression(s) }
+        return false unless result
 
-        res.size > 1 ? { type: :function, identifier: 'or', args: res } : res.first
+        result.size > 1 ? { type: :function, identifier: :or, args: result } : result.first
       end
 
       def and_expression(str)
-        res = []
-        split = str.split(/,/)
-        temp = ''
-        while split.any?
-          temp += split.shift
-          temp_and_exp = function(temp) || group(temp) || and_strict(temp)
-          if temp_and_exp
-            res.push(temp_and_exp)
-            temp = ''
-          else
-            temp += ','
-          end
-        end
-        return false if temp.present?
+        result = repeat_pattern(str, COMMA_DELIMITER) { |s| function(s) || group(s) || and_strict(s) }
+        return false unless result
 
-        res.size > 1 ? { type: :function, identifier: 'and', args: res } : res.first
+        result.size > 1 ? { type: :function, identifier: :and, args: result } : result.first
       end
 
       def and_strict(str)
-        res = []
-        split = str.split(/&/)
-        temp = ''
-        while split.any?
-          temp += split.shift
-          temp_and_exp = function(temp) || group(temp)
-          if temp_and_exp
-            res.push(temp_and_exp)
-            temp = ''
-          else
-            temp += ','
-          end
-        end
-        return false if temp.present?
+        result = repeat_pattern(str, AND_STRICT_DELIMITERS) { |s| function(s) || group(s) }
+        return false unless result
 
-        res.size > 1 ? { type: :function, identifier: 'and', args: res } : res.first
+        result.size > 1 ? { type: :function, identifier: :and, args: result } : result.first
       end
 
       def function(str)
-        res = false
-        if /\A[a-z]+\(.+\)\z/.match?(str)
-          identifier = str.match(/\A([a-z]+)/)[1]
-          args = str.match(/\A[a-z]+\((.+)\)\z/)[1]
-          temp_args = args(args)
-          res = { type: :function, identifier: identifier, args: temp_args } if temp_args
-        end
-        res
+        return false unless FUNCTION_REGEX.match?(str)
+
+        identifier = str.match(FUNCTION_IDENTIFIER)[1]
+        args = args(str.match(FUNCTION_ARGS)[1])
+
+        return false unless args
+
+        { type: :function, identifier: identifier.to_sym, args: args }
       end
 
       def args(str)
-        res = []
-        split = str.split(',')
-        temp = ''
-        while split.any?
-          temp += split.shift
-          temp_arg = arg(temp)
-          if temp_arg
-            res.push(temp_arg)
-            temp = ''
-          else
-            temp += ','
-          end
-        end
-        return false if temp.present?
-
-        res
+        repeat_pattern(str, COMMA_DELIMITER) { |s| arg(s) }
       end
 
       def arg(str)
@@ -119,33 +72,42 @@ module RqlParser
       end
 
       def array_of_values(str)
-        return false unless /\A\(.+\)\z/.match?(str)
+        return false unless BRACES_REGEX.match?(str)
 
-        res = []
-        split = str[1..-2].split(',')
-        temp = ''
-        while split.any?
-          temp += split.shift
-          temp_arg = value(temp)
-          if temp_arg
-            res.push(temp_arg)
-            temp = ''
-          else
-            temp += ','
-          end
-        end
-        return false if temp.present?
+        result = repeat_pattern(str[1..-2], COMMA_DELIMITER) { |s| value(s) }
+        return false unless result
 
-        { arg_array: res }
+        { arg_array: result }
       end
 
       def value(str)
-        if str.match?(/\A[_0-9a-zA-Z]+\z/)
+        if str.match?(VALUE_REGEX)
           { arg: str }
         else
           false
         end
       end
+
+      def repeat_pattern(str, split_regex)
+        split = str.split(split_regex)
+        result = []
+        expression = ''
+        while split.any?
+          expression += split.shift
+          bin_tree = yield(expression)
+          if bin_tree
+            result.push(bin_tree)
+            expression = ''
+          else
+            expression += compose_char(split_regex)
+          end
+        end
+        expression.blank? && result
+      end
+
+      def compose_char(regex)
+        DELIMITERS.match(regex)[0]
+      end
     end
   end
 end

data/lib/rql_parser/version.rb

@@ -1,3 +1,3 @@
 module RqlParser
-  VERSION = '0.0.1alpha4'.freeze
+  VERSION = '1.0.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rql_parser
 version: !ruby/object:Gem::Version
-  version: 0.0.1alpha4
+  version: 1.0.0
 platform: ruby
 authors:
 - Aliaksei Kharkou
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-12-26 00:00:00.000000000 Z
+date: 2018-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_interaction
@@ -110,9 +110,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.7.6