query-ruby 0.1.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ac8665b3965512fc0ec7deb35364d8dcfeeaa4d7314bd79b98a8e03429063f0
-  data.tar.gz: de6848d68312bc5c612953e12968b775a8a3b7971051b1cd80ec274765539a5c
+  metadata.gz: 637f0d62e9d40ea882160cc00f8e10fd09cb2ad730387c29d2170a07150ff894
+  data.tar.gz: f4617293cd65815243117e7d939a7b98102da0c2c4d77c7dd692e2b1618c1187
 SHA512:
-  metadata.gz: c5db80249c3f4b02d054453acea39ae197b35768d84dba7698b0c3a9dcfd6aafc77cc7e483893309b74e55c346c4af7fb507c67cf7902f41478f275429d07d57
-  data.tar.gz: e6d66eed9e04b42164f7a0542c1450996b511c8bcb9bf0a05e46ab5336202056f81370710a8552d8073ee79e5aaaaf02ce168d727da581f085b4613e8d812963
+  metadata.gz: 5c46fea9d0bad92f106400380c9b095746141b5eb312970b26a15cbb2b39010b4e5a4d6738ed6e3f3e2dfd4a4cb94ab1e2451ccba2da9270818ca1140a170c3c
+  data.tar.gz: 62519e0608c41d5b3348822380ca50ef3b501c5561aa0067a1f325029a210a79fa4e1eb9432ef47fc553712a06c414e6a035233e1f1f5697b9a2d45ce38ff3de

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    query-ruby (0.1.0)
+    query-ruby (1.1.0)
       activesupport
       bigdecimal
       dorian-arguments

data/VERSION

@@ -1 +1 @@
-0.1.0
+1.1.0

data/bin/query

@@ -35,14 +35,14 @@ parsed =
 abort Query::Version.to_s if parsed.options.version
 abort parsed.help if parsed.options.help
 
-inputs = [parsed.options.input.to_s]
+inputs = [parsed.options.input.to_s].compact_blank
 inputs += parsed.arguments
 inputs += parsed.files.map { |file| File.read(file) }
 
 input = inputs.join(" ")
 
 if parsed.options.parse
-  pp Query::Parser.parse(input).to_raw
+  pp Query.parse(input)
 elsif parsed.options.decompile
   puts Query.decompile(Query.evaluate(input))
 elsif parsed.options.combine

data/lib/query/combiner.rb

@@ -11,13 +11,10 @@ class Query
     end
 
     def combine
-      sources.map do |source|
-        Query.evaluate(source)
-      end.reduce do |acc, element|
-        combine_parsed(acc, element)
-      end.then do |parsed|
-        Query.decompile(parsed)
-      end
+      sources
+        .map { |source| Query.evaluate(source) }
+        .reduce { |acc, element| combine_parsed(acc, element) }
+        .then { |parsed| Query.decompile(parsed) }
     end
 
     private
@@ -25,9 +22,10 @@ class Query
     attr_accessor :sources
 
     def combine_parsed(left, right)
-      (left + right).reverse.uniq do |node|
-        node.is_a?(Hash) ? [node[:key], node[:operator]] : node
-      end.reverse
+      (left + right)
+        .reverse
+        .uniq { |node| node.is_a?(Hash) ? [node[:key], node[:operator]] : node }
+        .reverse
     end
   end
 end

data/lib/query/decompiler.rb

@@ -11,17 +11,33 @@ class Query
     end
 
     def decompile
-      parsed.map { |node| format_value(node) }.join(" ")
+      if parsed.is_a?(Hash) && parsed.key?(:left)
+        format_logic_operator(parsed)
+      elsif parsed.is_a?(Hash) && parsed.key?(:right)
+        format_not_operator(parsed)
+      else
+        format_value(parsed)
+      end
+    end
+
+    def format_logic_operator(parsed)
+      left = self.class.decompile(parsed[:left])
+      right = self.class.decompile(parsed[:right])
+
+      "(#{left} #{parsed[:operator]} #{right})"
     end
 
-    def format_string(string)
+    def format_not_operator(parsed)
+      right = self.class.decompile(parsed[:right])
+
+      "(#{parsed[:operator]} #{right})"
     end
 
     def format_value(value)
       if value.is_a?(Hash)
         "#{value[:key]}#{value[:operator]}#{format_value(value[:value])}"
       elsif value.is_a?(String)
-        Query.evaluate(value).many? ? value.inspect : value
+        Query.evaluate(value).is_a?(Hash) ? value.inspect : value
       elsif value.is_a?(BigDecimal)
         value.to_s("F")
       elsif value.is_a?(Range)

data/lib/query/node/base_10.rb

@@ -7,15 +7,12 @@ class Query
 
       def initialize(parsed)
         self.whole = parsed.delete(:whole)
-        self.exponent = Node::Value.new(parsed.delete(:exponent)) if parsed.key?(:exponent)
+        self.exponent =
+          Node::Value.new(parsed.delete(:exponent)) if parsed.key?(:exponent)
       end
 
       def evaluate(**args)
-        if exponent
-          whole.to_i * 10 ** exponent.evaluate(**args)
-        else
-          whole.to_i
-        end
+        exponent ? whole.to_i * 10**exponent.evaluate(**args) : whole.to_i
       end
     end
   end

data/lib/query/node/boolean.rb

@@ -31,7 +31,7 @@ class Query
         "N" => false,
         "off" => false,
         "Off" => false,
-        "OFF" => false,
+        "OFF" => false
       }
 
       def initialize(parsed)

data/lib/query/node/decimal.rb

@@ -15,7 +15,7 @@ class Query
 
       def evaluate(**args)
         if exponent
-          BigDecimal(decimal) * 10 ** exponent.evaluate(**args)
+          BigDecimal(decimal) * 10**exponent.evaluate(**args)
         else
           BigDecimal(decimal)
         end

data/lib/query/node/operator.rb

@@ -3,9 +3,11 @@
 class Query
   class Node
     class Operator < Node
-      attr_accessor :operator
+      attr_accessor :prefix, :suffix
 
-      OPERATORS = {
+      PREFIXES = { "+" => "", "-" => "!", "!" => "!", "" => "", nil => "" }
+
+      SUFFIXES = {
         "^" => "^",
         "$" => "$",
         ">=" => ">=",
@@ -20,15 +22,16 @@ class Query
         ":" => ":",
         "=" => "=",
         "==" => "=",
-        "===" => "=",
+        "===" => "="
       }
 
       def initialize(parsed)
-        self.operator = parsed
+        self.prefix = parsed.delete(:prefix)
+        self.suffix = parsed.delete(:suffix)
       end
 
       def evaluate(**args)
-        OPERATORS.fetch(operator)
+        "#{PREFIXES.fetch(prefix)}#{SUFFIXES.fetch(suffix)}"
       end
     end
   end

data/lib/query/node/query.rb

@@ -3,14 +3,72 @@
 class Query
   class Node
     class Query < Node
-      attr_accessor :parts
+      attr_accessor :left, :operator, :right, :query, :negative
+
+      LOGIC_OPERATORS = {
+        "or" => "or",
+        "Or" => "or",
+        "OR" => "or",
+        "||" => "or",
+        "|" => "or",
+        "and" => "and",
+        "And" => "and",
+        "AND" => "and",
+        "&&" => "and",
+        "&" => "and",
+        "" => "and",
+        nil => "and"
+      }
+
+      NEGATIVE_OPERATORS = {
+        "not" => "not",
+        "Not" => "not",
+        "NOT" => "not",
+        "!" => "not"
+      }
 
       def initialize(parsed)
-        self.parts = (parsed.presence || []).map { |part| Part.new(part) }
+        self.negative = (parsed.presence || {}).delete(:not)
+
+        if parsed.is_a?(Hash)
+          if parsed.key?(:key_value)
+            self.query = KeyValue.new(parsed.delete(:key_value))
+          elsif parsed.key?(:string)
+            self.query = String.new(parsed.delete(:string))
+          else
+            self.left = Query.new(parsed.delete(:left))
+            self.operator = parsed.delete(:operator)
+            self.right = Query.new(parsed.delete(:right))
+          end
+        else
+          self.query = String.new(parsed)
+        end
       end
 
       def evaluate(**args)
-        parts.map { |part| part.evaluate(**args) }
+        if negative && query
+          {
+            operator: NEGATIVE_OPERATORS.fetch(negative),
+            right: query.evaluate(**args)
+          }
+        elsif negative
+          {
+            operator: NEGATIVE_OPERATORS.fetch(negative),
+            right: {
+              left: left.evaluate(**args),
+              operator: LOGIC_OPERATORS.fetch(operator),
+              right: right.evaluate(**args)
+            }
+          }
+        elsif query
+          query.evaluate(**args)
+        else
+          {
+            left: left.evaluate(**args),
+            operator: LOGIC_OPERATORS.fetch(operator),
+            right: right.evaluate(**args)
+          }
+        end
       end
     end
   end

data/lib/query/parser/boolean.rb

@@ -3,20 +3,16 @@
 class Query
   class Parser
     class Boolean < Language
-      def special
-        str("...") | str("..") | Whitespace | Operator
-      end
-
       def root
         (
           (
             str("true") | str("t") | str("True") | str("TRUE") | str("T") |
               str("yes") | str("y") | str("Yes") | str("YES") | str("Y") |
               str("on") | str("On") | str("ON")
-              str("false") | str("f") | str("False") | str("FALSE") |
-                str("F") | str("no") | str("n") | str("No") | str("NO") |
-                str("N") | str("off") | str("Off") | str("OFF")
-          ) << special.present
+            str("false") | str("f") | str("False") | str("FALSE") | str("F") |
+              str("no") | str("n") | str("No") | str("NO") | str("N") |
+              str("off") | str("Off") | str("OFF")
+          ) << Special.present
         ).aka(:boolean)
       end
     end

data/lib/query/parser/group.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class Query
+  class Parser
+    class Group < Language
+      def root
+        str("(").ignore << Whitespace.maybe << Part.maybe <<
+          (Whitespace.maybe << str(")").ignore).maybe
+      end
+    end
+  end
+end

data/lib/query/parser/key.rb

@@ -4,7 +4,7 @@ class Query
   class Parser
     class Key < Language
       def root
-        str("_").absent << (Whitespace.absent << Operator.absent << any).repeat(1)
+        (Special.absent << Operator.absent << any).repeat(1).aka(:key)
       end
     end
   end

data/lib/query/parser/key_value.rb

@@ -4,9 +4,7 @@ class Query
   class Parser
     class KeyValue < Language
       def root
-        (Key.aka(:key) << Operator.aka(:operator) << Value.aka(:value)).aka(
-          :key_value
-        )
+        (Key << Operator << Value).aka(:key_value)
       end
     end
   end

data/lib/query/parser/logic_operator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Query
+  class Parser
+    class LogicOperator < Language
+      def root
+        (
+          Whitespace << (
+            str("and") | str("And") | str("AND") | str("or") | str("Or") |
+              str("OR")
+          ) << Whitespace
+        ) |
+          (
+            Whitespace.maybe << (
+              str("&&") | str("&") | str("||") | str("|") | str("")
+            ) << Whitespace.maybe
+          )
+      end
+    end
+  end
+end

data/lib/query/parser/not_operator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Query
+  class Parser
+    class NotOperator < Language
+      def root
+        ((str("not") | str("Not") | str("NOT")) << Whitespace) | str("!")
+      end
+    end
+  end
+end

data/lib/query/parser/number.rb

@@ -3,10 +3,6 @@
 class Query
   class Parser
     class Number < Language
-      def special
-        str("...") | str("..") | Whitespace | Operator
-      end
-
       def zero
         str("0")
       end
@@ -150,7 +146,7 @@ class Query
             decimal.aka(:decimal) | base_16_number.aka(:base_16) |
               base_8_number.aka(:base_8) | base_2_number.aka(:base_2) |
               base_10_number.aka(:base_10)
-          ) << special.present
+          ) << Special.present
         ).aka(:number)
       end
     end

data/lib/query/parser/operator.rb

@@ -3,39 +3,36 @@
 class Query
   class Parser
     class Operator < Language
-      OPERATORS = [
-        "^",
-        "$",
-        ">=",
-        "=>",
-        "<=",
-        "=<",
-        "<",
-        ">",
-        "!",
-      ]
+      PREFIXES = %w[- + !]
 
-      MODIFIERS = [
-        ":::",
-        "::",
-        ":",
-        "===",
-        "==",
-        "=",
-        "",
-      ]
+      OPERATORS = %w[^ $ >= => <= =< < > !]
+
+      MODIFIERS = [":::", "::", ":", "===", "==", "=", ""]
 
       def root
-        OPERATORS.flat_map do |operator|
-          MODIFIERS.map do |modifier|
-            str("#{operator}#{modifier}") |
-              str("#{modifier}#{operator}") |
-              str(operator)
-          end.reduce(&:|).then { operator }
-        end.reduce(&:|) |
-          MODIFIERS.compact_blank.map do |modifier|
-            str(modifier)
-          end.reduce(&:|)
+        (
+          PREFIXES
+            .map { |prefix| str(prefix) }
+            .reduce(&:|)
+            .aka(:prefix)
+            .maybe << (
+            OPERATORS
+              .flat_map do |operator|
+                MODIFIERS
+                  .map do |modifier|
+                    str("#{operator}#{modifier}") |
+                      str("#{modifier}#{operator}") | str(operator)
+                  end
+                  .reduce(&:|)
+                  .then { operator }
+              end
+              .reduce(&:|) |
+              MODIFIERS
+                .compact_blank
+                .map { |modifier| str(modifier) }
+                .reduce(&:|)
+          ).aka(:suffix)
+        ).aka(:operator)
       end
     end
   end

data/lib/query/parser/part.rb

@@ -4,7 +4,10 @@ class Query
   class Parser
     class Part < Language
       def root
-        KeyValue | Text
+        (
+          Statement.aka(:left) << LogicOperator.aka(:operator) <<
+            Part.aka(:right)
+        ) | Statement
       end
     end
   end

data/lib/query/parser/query.rb

@@ -3,12 +3,8 @@
 class Query
   class Parser
     class Query < Language
-      def whitespace?
-        Whitespace.maybe
-      end
-
       def root
-        whitespace? << (Part << Whitespace).repeat | any.repeat | whitespace?
+        Whitespace.maybe << Part.maybe << Whitespace.maybe
       end
     end
   end

data/lib/query/parser/range.rb

@@ -11,20 +11,17 @@ class Query
         Whitespace.maybe
       end
 
-      def special
-        str("...") | str("..") | Whitespace | Operator
-      end
-
       def root
         (
           (
             (
               Number.aka(:left) << operator.aka(:operator) << Number.aka(:right)
             ) |
-            (
-              String.aka(:left) << operator.aka(:operator) << String.aka(:right)
-            )
-          ) << special.present
+              (
+                String.aka(:left) << operator.aka(:operator) <<
+                  String.aka(:right)
+              )
+          ) << Special.present
         ).aka(:range)
       end
     end

data/lib/query/parser/special.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class Query
+  class Parser
+    class Special < Language
+      def root
+        str("&") | str("|") | str("(") | str(")") | str("...") | str("..") |
+          Whitespace
+      end
+    end
+  end
+end

data/lib/query/parser/statement.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Query
+  class Parser
+    class Statement < Language
+      def root
+        (
+          Whitespace.maybe << NotOperator.aka(:not) << Whitespace.maybe
+        ).maybe << (Group | KeyValue | String)
+      end
+    end
+  end
+end

data/lib/query/parser/string.rb

@@ -15,10 +15,6 @@ class Query
         str("\\")
       end
 
-      def special
-        str("...") | str("..") | Whitespace | Operator
-      end
-
       def double_quoted_string
         double_quote.ignore << (
           (backslash.ignore << double_quote) | (double_quote.absent << any)
@@ -35,8 +31,8 @@ class Query
         (
           (
             double_quoted_string | single_quoted_string |
-              (special.absent << any).repeat(1)
-          ) << special.present
+              (Special.absent << any).repeat(1)
+          ) << Special.present
         ).aka(:string)
       end
     end

data/lib/query/parser/value.rb

@@ -4,7 +4,7 @@ class Query
   class Parser
     class Value < Language
       def root
-        Range | KeyValue | Boolean | Number | String
+        (Range | KeyValue | Boolean | Number | String).aka(:value)
       end
     end
   end

data/spec/query_spec.rb

@@ -57,15 +57,18 @@ RSpec.describe Query do
     "verified:f",
     "verified:off",
     "verified:no",
+    "a b",
+    "a or b",
+    "a:1 or b",
+    "a:1 or b:2..3",
+    "(a or b) and (not b ! c)"
   ].each do |source|
     it source.inspect do
       Query.evaluate(source)
     end
 
     it "decompiles #{source.inspect}" do
-      expect(
-        Query.evaluate(Query.decompile(Query.evaluate(source)))
-      ).to eq(
+      expect(Query.evaluate(Query.decompile(Query.evaluate(source)))).to eq(
         Query.evaluate(source)
       )
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: query-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Dorian Marié
 bindir: bin
 cert_chain: []
-date: 2025-04-23 00:00:00.000000000 Z
+date: 2025-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -132,23 +132,25 @@ files:
 - lib/query/node/key_value.rb
 - lib/query/node/number.rb
 - lib/query/node/operator.rb
-- lib/query/node/part.rb
 - lib/query/node/query.rb
 - lib/query/node/range.rb
 - lib/query/node/string.rb
-- lib/query/node/text.rb
 - lib/query/node/value.rb
 - lib/query/parser.rb
 - lib/query/parser/boolean.rb
+- lib/query/parser/group.rb
 - lib/query/parser/key.rb
 - lib/query/parser/key_value.rb
+- lib/query/parser/logic_operator.rb
+- lib/query/parser/not_operator.rb
 - lib/query/parser/number.rb
 - lib/query/parser/operator.rb
 - lib/query/parser/part.rb
 - lib/query/parser/query.rb
 - lib/query/parser/range.rb
+- lib/query/parser/special.rb
+- lib/query/parser/statement.rb
 - lib/query/parser/string.rb
-- lib/query/parser/text.rb
 - lib/query/parser/value.rb
 - lib/query/parser/whitespace.rb
 - lib/query/version.rb

data/lib/query/node/part.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-class Query
-  class Node
-    class Part < Node
-      attr_accessor :part
-
-      def initialize(parsed)
-        if parsed.key?(:key_value)
-          self.part = KeyValue.new(parsed.delete(:key_value))
-        elsif parsed.key?(:text)
-          self.part = Text.new(parsed.delete(:text))
-        end
-      end
-
-      def evaluate(**args)
-        part&.evaluate(**args)
-      end
-    end
-  end
-end

data/lib/query/node/text.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-class Query
-  class Node
-    class Text < Node
-      attr_accessor :text
-
-      def initialize(parsed)
-        self.text = parsed.presence
-      end
-
-      def evaluate(**args)
-        text
-      end
-    end
-  end
-end

data/lib/query/parser/text.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-class Query
-  class Parser
-    class Text < Language
-      def double_quote
-        str('"')
-      end
-
-      def single_quote
-        str("'")
-      end
-
-      def backslash
-        str("\\")
-      end
-
-      def double_quoted_string
-        double_quote.ignore << (
-          (backslash.ignore << double_quote) | (double_quote.absent << any)
-        ).repeat << double_quote.maybe.ignore
-      end
-
-      def single_quoted_string
-        single_quote.ignore << (
-          (backslash.ignore << single_quote) | (single_quote.absent << any)
-        ).repeat << single_quote.maybe.ignore
-      end
-
-      def root
-        (
-          (
-            double_quoted_string | single_quoted_string |
-              (Whitespace.absent << any).repeat(1)
-          ) << Whitespace.present
-        ).aka(:text)
-      end
-    end
-  end
-end