query-ruby 0.1.0

data/lib/query/node/base_16.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Query
+  class Node
+    class Base16 < Node
+      attr_accessor :base_16
+
+      def initialize(parsed)
+        self.base_16 = parsed
+      end
+
+      def evaluate(**_args)
+        base_16.to_i(16)
+      end
+    end
+  end
+end

data/lib/query/node/base_2.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Query
+  class Node
+    class Base2 < Node
+      attr_accessor :base_2
+
+      def initialize(parsed)
+        self.base_2 = parsed
+      end
+
+      def evaluate(**_args)
+        base_2.to_i(2)
+      end
+    end
+  end
+end

data/lib/query/node/base_8.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Query
+  class Node
+    class Base8 < Node
+      attr_accessor :base_8
+
+      def initialize(parsed)
+        self.base_8 = parsed
+      end
+
+      def evaluate(**_args)
+        base_8.to_i(8)
+      end
+    end
+  end
+end

data/lib/query/node/boolean.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class Query
+  class Node
+    class Boolean < Node
+      attr_accessor :boolean
+
+      BOOLEANS = {
+        "true" => true,
+        "t" => true,
+        "True" => true,
+        "TRUE" => true,
+        "T" => true,
+        "yes" => true,
+        "y" => true,
+        "Yes" => true,
+        "YES" => true,
+        "Y" => true,
+        "on" => true,
+        "On" => true,
+        "ON" => true,
+        "false" => false,
+        "f" => false,
+        "False" => false,
+        "FALSE" => false,
+        "F" => false,
+        "no" => false,
+        "n" => false,
+        "No" => false,
+        "NO" => false,
+        "N" => false,
+        "off" => false,
+        "Off" => false,
+        "OFF" => false,
+      }
+
+      def initialize(parsed)
+        self.boolean = parsed
+      end
+
+      def evaluate(**args)
+        BOOLEANS.fetch(boolean)
+      end
+    end
+  end
+end

data/lib/query/node/decimal.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Query
+  class Node
+    class Decimal < Node
+      attr_accessor :decimal, :exponent
+
+      def initialize(parsed)
+        self.decimal = parsed.delete(:decimal)
+
+        if parsed.key?(:exponent)
+          self.exponent = Value.new(parsed.delete(:exponent))
+        end
+      end
+
+      def evaluate(**args)
+        if exponent
+          BigDecimal(decimal) * 10 ** exponent.evaluate(**args)
+        else
+          BigDecimal(decimal)
+        end
+      end
+    end
+  end
+end

data/lib/query/node/key.rb

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

data/lib/query/node/key_value.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Query
+  class Node
+    class KeyValue < Node
+      attr_accessor :key, :operator, :value
+
+      def initialize(parsed)
+        self.key = Key.new(parsed.delete(:key))
+        self.operator = Operator.new(parsed.delete(:operator))
+        self.value = Value.new(parsed.delete(:value))
+      end
+
+      def evaluate(**args)
+        {
+          key: key.evaluate(**args),
+          operator: operator.evaluate(**args),
+          value: value.evaluate(**args)
+        }
+      end
+    end
+  end
+end

data/lib/query/node/number.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Query
+  class Node
+    class Number < Node
+      attr_accessor :value
+
+      def initialize(parsed)
+        if parsed.key?(:decimal)
+          self.value = Decimal.new(parsed.delete(:decimal))
+        elsif parsed.key?(:base_16)
+          self.value = Base16.new(parsed.delete(:base_16))
+        elsif parsed.key?(:base_8)
+          self.value = Base8.new(parsed.delete(:base_8))
+        elsif parsed.key?(:base_2)
+          self.value = Base2.new(parsed.delete(:base_2))
+        else
+          self.value = Base10.new(parsed.delete(:base_10))
+        end
+      end
+
+      def evaluate(**args)
+        value.evaluate(**args)
+      end
+    end
+  end
+end

data/lib/query/node/operator.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class Query
+  class Node
+    class Operator < Node
+      attr_accessor :operator
+
+      OPERATORS = {
+        "^" => "^",
+        "$" => "$",
+        ">=" => ">=",
+        "=>" => ">=",
+        "<=" => "<=",
+        "=<" => "<=",
+        "<" => "<",
+        ">" => ">",
+        "!" => "!",
+        ":::" => ":",
+        "::" => ":",
+        ":" => ":",
+        "=" => "=",
+        "==" => "=",
+        "===" => "=",
+      }
+
+      def initialize(parsed)
+        self.operator = parsed
+      end
+
+      def evaluate(**args)
+        OPERATORS.fetch(operator)
+      end
+    end
+  end
+end

data/lib/query/node/part.rb

@@ -0,0 +1,21 @@
+# 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/query.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Query
+  class Node
+    class Query < Node
+      attr_accessor :parts
+
+      def initialize(parsed)
+        self.parts = (parsed.presence || []).map { |part| Part.new(part) }
+      end
+
+      def evaluate(**args)
+        parts.map { |part| part.evaluate(**args) }
+      end
+    end
+  end
+end

data/lib/query/node/range.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Query
+  class Node
+    class Range < Node
+      attr_accessor :left, :right, :operator
+
+      def initialize(parsed)
+        self.left = Value.new(parsed.delete(:left))
+        self.operator = parsed.delete(:operator)
+        self.right = Value.new(parsed.delete(:right))
+      end
+
+      def evaluate(**args)
+        if operator == "..."
+          (left.evaluate(**args))...(right.evaluate(**args))
+        else
+          (left.evaluate(**args))..(right.evaluate(**args))
+        end
+      end
+    end
+  end
+end

data/lib/query/node/string.rb

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

data/lib/query/node/text.rb

@@ -0,0 +1,17 @@
+# 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/node/value.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Query
+  class Node
+    class Value < Node
+      attr_accessor :value
+
+      def initialize(parsed)
+        if parsed.key?(:key_value)
+          self.value = KeyValue.new(parsed.delete(:key_value))
+        elsif parsed.key?(:boolean)
+          self.value = Boolean.new(parsed.delete(:boolean))
+        elsif parsed.key?(:number)
+          self.value = Number.new(parsed.delete(:number))
+        elsif parsed.key?(:string)
+          self.value = String.new(parsed.delete(:string))
+        elsif parsed.key?(:range)
+          self.value = Range.new(parsed.delete(:range))
+        end
+      end
+
+      def evaluate(**args)
+        value.evaluate(**args)
+      end
+    end
+  end
+end

data/lib/query/node.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Query
+  class Node
+    def evaluate(**_args)
+      Object::Nothing.new
+    end
+  end
+end

data/lib/query/parser/boolean.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+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
+        ).aka(:boolean)
+      end
+    end
+  end
+end

data/lib/query/parser/key.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Query
+  class Parser
+    class Key < Language
+      def root
+        str("_").absent << (Whitespace.absent << Operator.absent << any).repeat(1)
+      end
+    end
+  end
+end

data/lib/query/parser/key_value.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Query
+  class Parser
+    class KeyValue < Language
+      def root
+        (Key.aka(:key) << Operator.aka(:operator) << Value.aka(:value)).aka(
+          :key_value
+        )
+      end
+    end
+  end
+end

data/lib/query/parser/number.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+class Query
+  class Parser
+    class Number < Language
+      def special
+        str("...") | str("..") | Whitespace | Operator
+      end
+
+      def zero
+        str("0")
+      end
+
+      def one
+        str("1")
+      end
+
+      def two
+        str("2")
+      end
+
+      def three
+        str("3")
+      end
+
+      def four
+        str("4")
+      end
+
+      def five
+        str("5")
+      end
+
+      def six
+        str("6")
+      end
+
+      def seven
+        str("7")
+      end
+
+      def eight
+        str("8")
+      end
+
+      def nine
+        str("9")
+      end
+
+      def dot
+        str(".")
+      end
+
+      def a
+        str("a") | str("A")
+      end
+
+      def b
+        str("b") | str("B")
+      end
+
+      def c
+        str("c") | str("C")
+      end
+
+      def d
+        str("d") | str("D")
+      end
+
+      def e
+        str("e") | str("E")
+      end
+
+      def f
+        str("f") | str("F")
+      end
+
+      def o
+        str("o") | str("O")
+      end
+
+      def x
+        str("x") | str("X")
+      end
+
+      def underscore
+        str("_")
+      end
+
+      def base_16_digit
+        zero | one | two | three | four | five | six | seven | eight | nine |
+          a | b | c | d | e | f
+      end
+
+      def base_10_digit
+        zero | one | two | three | four | five | six | seven | eight | nine
+      end
+
+      def base_8_digit
+        zero | one | two | three | four | five | six | seven
+      end
+
+      def base_2_digit
+        zero | one
+      end
+
+      def base_16_whole
+        base_16_digit << (underscore.ignore | base_16_digit).repeat
+      end
+
+      def base_10_whole
+        base_10_digit << (underscore.ignore | base_10_digit).repeat
+      end
+
+      def base_8_whole
+        base_8_digit << (underscore.ignore | base_8_digit).repeat
+      end
+
+      def base_2_whole
+        base_2_digit << (underscore.ignore | base_2_digit).repeat
+      end
+
+      def exponent
+        (e << Number).aka(:exponent)
+      end
+
+      def decimal
+        (base_10_whole << dot << base_10_whole).aka(:decimal) << exponent.maybe
+      end
+
+      def base_16_number
+        zero.ignore << x.ignore << base_16_whole
+      end
+
+      def base_10_number
+        base_10_whole.aka(:whole) << exponent.maybe
+      end
+
+      def base_8_number
+        zero.ignore << o.ignore << base_8_whole
+      end
+
+      def base_2_number
+        zero.ignore << b.ignore << base_2_whole
+      end
+
+      def root
+        (
+          (
+            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
+        ).aka(:number)
+      end
+    end
+  end
+end

data/lib/query/parser/operator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class Query
+  class Parser
+    class Operator < Language
+      OPERATORS = [
+        "^",
+        "$",
+        ">=",
+        "=>",
+        "<=",
+        "=<",
+        "<",
+        ">",
+        "!",
+      ]
+
+      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(&:|)
+      end
+    end
+  end
+end

data/lib/query/parser/part.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Query
+  class Parser
+    class Part < Language
+      def root
+        KeyValue | Text
+      end
+    end
+  end
+end

data/lib/query/parser/query.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Query
+  class Parser
+    class Query < Language
+      def whitespace?
+        Whitespace.maybe
+      end
+
+      def root
+        whitespace? << (Part << Whitespace).repeat | any.repeat | whitespace?
+      end
+    end
+  end
+end

data/lib/query/parser/range.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class Query
+  class Parser
+    class Range < Language
+      def operator
+        str("...") | str("..")
+      end
+
+      def whitespace?
+        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
+        ).aka(:range)
+      end
+    end
+  end
+end