kql 1.0.0

data/lib/kql/mapping.rb

@@ -0,0 +1,23 @@
+require_relative './query'
+
+module KQL
+  class Mapping < Query
+    attr_accessor :mapping
+
+    def initialize(alternatives, mapping)
+      super(alternatives)
+      @mapping = mapping
+    end
+
+    def execute(document)
+      nodes = super
+      nodes.map { |node| mapping.execute(node) }
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Mapping)
+
+      super(other) && other.mapping = mapping
+    end
+  end
+end

data/lib/kql/matcher.rb

@@ -0,0 +1,86 @@
+module KQL
+  class Matcher
+    singleton :Any, Matcher do
+      def match?(node)
+        true
+      end
+    end
+
+    singleton :AnyTag, Matcher do
+      def match?(node)
+        !node.type.nil?
+      end
+    end
+
+    class Tag < Matcher
+      attr_reader :tag
+      alias value tag
+
+      def initialize(tag)
+        @tag = tag
+      end
+
+      def match?(node)
+        node.type == tag
+      end
+
+      def ==(other)
+        return false unless other.is_a?(Tag)
+
+        other.tag == tag
+      end
+
+      def coerce(a)
+        case a
+        when ::KDL::Node, ::KDL::Value then a.type
+        else a
+        end
+      end
+    end
+
+    class Value < Matcher
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def ==(other)
+        return false unless other.is_a?(Value)
+
+        other.value == value
+      end
+
+      def coerce(a)
+        case a
+        when ::KDL::Value then a.value
+        else a
+        end
+      end
+    end
+
+    class Comparison < Matcher
+      attr_reader :accessor, :operator, :value
+
+      def initialize(accessor, operator, value)
+        @accessor = accessor
+        @operator = operator
+        @value = value
+      end
+
+      def match?(node)
+        return false unless accessor.match?(node)
+
+        operator.execute(value.coerce(accessor.execute(node)), value.value)
+      end
+
+      def ==(other)
+        return false unless other.is_a?(Comparison)
+
+        other.accessor == accessor &&
+          other.operator == operator &&
+          other.value == value
+      end
+    end
+  end
+end

data/lib/kql/operator.rb

@@ -0,0 +1,57 @@
+module KQL
+  class Operator
+    singleton :Equals, Operator do
+      def execute(a, b)
+        a == b
+      end
+    end
+
+    singleton :NotEquals, Operator do
+      def execute(a, b)
+        a != b
+      end
+    end
+
+    singleton :GreaterThanOrEqual, Operator do
+      def execute(a, b)
+        a >= b
+      end
+    end
+
+    singleton :GreaterThan, Operator do
+      def execute(a, b)
+        a > b
+      end
+    end
+
+    singleton :LessThanOrEqual, Operator do
+      def execute(a, b)
+        a <= b
+      end
+    end
+
+    singleton :LessThan, Operator do
+      def execute(a, b)
+        a < b
+      end
+    end
+
+    singleton :StartsWith, Operator do
+      def execute(a, b)
+        a.start_with?(b)
+      end
+    end
+
+    singleton :EndsWith, Operator do
+      def execute(a, b)
+        a.end_with?(b)
+      end
+    end
+
+    singleton :Includes, Operator do
+      def execute(a, b)
+        a.include?(b)
+      end
+    end
+  end
+end

data/lib/kql/query.rb

@@ -0,0 +1,77 @@
+module KQL
+  class Query
+    attr_reader :alternatives
+
+    def initialize(alternatives)
+      @alternatives = alternatives
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Query)
+
+      other.alternatives == alternatives
+    end
+
+    def execute(document)
+      alternatives.flat_map do |alt|
+        alt.execute(TopContext.new(document))
+           .nodes
+           .uniq { |n| n.__id__ }
+      end
+    end
+
+    private
+
+    class Context
+      attr_accessor :selected_nodes
+
+      def initialize(selected_nodes)
+        @selected_nodes = selected_nodes
+      end
+
+      def nodes
+        selected_nodes.map(&:node)
+      end
+
+      def children(**kwargs)
+        nodes.flat_map do |node|
+          node.children
+              .each_with_index
+              .map { |n, i| Query::SelectedNode.new(n, node.children, i, **kwargs) }
+        end
+      end
+
+      def top?
+        false
+      end
+    end
+
+    class TopContext < Context
+      attr_accessor :document
+
+      def initialize(document)
+        @document = document
+        super(children)
+      end
+
+      def children(**kwargs)
+        document.nodes.each_with_index.map { |n, i| Query::SelectedNode.new(n, document.nodes, i, **kwargs) }
+      end
+
+      def top?
+        true
+      end
+    end
+
+    class SelectedNode
+      attr_accessor :node, :siblings, :index, :stop
+
+      def initialize(node, siblings, index, stop: false)
+        @node = node
+        @siblings = siblings
+        @index = index
+        @stop = stop
+      end
+    end
+  end
+end

data/lib/kql/selector.rb

@@ -0,0 +1,41 @@
+module KQL
+  class Selector
+    attr_reader :filter
+
+    def initialize(filter)
+      @filter = filter
+    end
+
+    def ==(other)
+      return false unless other.class == Selector
+
+      other.filter == filter
+    end
+
+    def execute(context)
+      filter.execute(context)
+    end
+
+    class Combined < Selector
+      attr_reader :combinator, :selector
+
+      def initialize(filter, combinator, selector)
+        super(filter)
+        @combinator = combinator
+        @selector = selector
+      end
+
+      def ==(other)
+        return false unless other.is_a?(Combined)
+
+        other.filter == filter &&
+          other.combinator == combinator &&
+          other.selector == selector
+      end
+
+      def execute(context)
+        combinator.execute(super, selector)
+      end
+    end
+  end
+end

data/lib/kql/tokenizer.rb

@@ -0,0 +1,302 @@
+module KQL
+  class Tokenizer
+    class Error < StandardError
+      def initialize(message, line, column)
+        super("#{message} (#{line}:#{column})")
+      end
+    end
+
+    class Token
+      attr_reader :type, :value, :line, :column
+
+      def initialize(type, value, line, column)
+        @type = type
+        @value = value
+        @line = line
+        @column = column
+      end
+
+      def ==(other  )
+        return false unless other.is_a?(Token)
+        return false unless type == other.type && value == other.value
+
+        if line && other.line
+          return false unless line == other.line
+        end
+        if column && other.column
+          return false unless column == other.column
+        end
+
+        true
+      end
+
+      def to_s
+        "#{value.inspect} (#{line || '?'}:#{column || '?'})"
+      end
+      alias inspect to_s
+    end
+
+    attr_reader :index
+
+    SYMBOLS = {
+      '(' => :LPAREN,
+      ')' => :RPAREN,
+      '[' => :LBRACKET,
+      ']' => :RBRACKET,
+      ',' => :COMMA
+    }
+
+    WHITESPACE = ["\u0009", "\u0020", "\u00A0", "\u1680",
+                 "\u2000", "\u2001", "\u2002", "\u2003",
+                 "\u2004", "\u2005", "\u2006", "\u2007",
+                 "\u2008", "\u2009", "\u200A", "\u202F",
+                 "\u205F", "\u3000", ' ']
+
+    NEWLINES = ["\u000A", "\u0085", "\u000C", "\u2028", "\u2029"]
+
+    NON_IDENTIFIER_CHARS = Regexp.escape "#{SYMBOLS.keys.join('')}()/\\<>[]\","
+    IDENTIFIER_CHARS = /[^#{NON_IDENTIFIER_CHARS}\x0-\x20]/
+    INITIAL_IDENTIFIER_CHARS = /[^#{NON_IDENTIFIER_CHARS}0-9\x0-\x20]/
+
+    def initialize(str, start = 0)
+      @str = str
+      @context = nil
+      @index = start
+      @buffer = ''
+      @previous_context = nil
+      @line = 1
+      @column = 1
+    end
+
+    def next_token
+      @context = nil
+      @previous_context = nil
+      @line_at_start = @line
+      @column_at_start = @column
+      loop do
+        c = @str[@index]
+        n = @str[@index + 1]
+        case @context
+        when nil
+          case c
+          when '"'
+            self.context = :string
+            @buffer = ''
+            traverse(1)
+          when /[0-9\-]/
+            self.context = :number
+            traverse(1)
+            @buffer = c
+          when '='
+            if n == '>'
+              return token(:MAP, '=>').tap { traverse(2) }
+            else
+              return token(:EQUALS, c).tap { traverse(1) }
+            end
+          when '>'
+            if n == '='
+              return token(:GTE, '>=').tap { traverse(2) }
+            else
+              return token(:GT, c).tap { traverse(1) }
+            end
+          when '<'
+            if n == '='
+              return token(:LTE, '<=').tap { traverse(2) }
+            else
+              return token(:LT, c).tap { traverse(1) }
+            end
+          when '|'
+            if n == '|'
+              return token(:OR, '||').tap { traverse(2) }
+            else
+              self.context = :ident
+              @buffer = c
+              traverse(1)
+            end
+          when '^'
+            if n == '='
+              return token(:STARTS_WITH, '^=').tap { traverse(2) }
+            else
+              self.context = :ident
+              @buffer = c
+              traverse(1)
+            end
+          when '$'
+            if n == '='
+              return token(:ENDS_WITH, '$=').tap { traverse(2) }
+            else
+              self.context = :ident
+              @buffer = c
+              traverse(1)
+            end
+          when '*'
+            if n == '='
+              return token(:INCLUDES, '*=').tap { traverse(2) }
+            else
+              self.context = :ident
+              @buffer = c
+              traverse(1)
+            end
+          when '+'
+            case n
+            when /[0-9]/
+              self.context = :number
+              traverse(1)
+              @buffer = c
+            when IDENTIFIER_CHARS
+              self.context = :ident
+              @buffer = c
+              traverse(1)
+            else
+              return token(:PLUS, '+').tap { traverse(1) }
+            end
+          when '~'
+            case n
+            when IDENTIFIER_CHARS
+              self.context = :ident
+              @buffer = c
+              traverse(1)
+            else
+              return token(:TILDE, '~').tap { traverse(1) }
+            end
+          when '!'
+            case n
+            when '='
+              return token(:NOT_EQUALS, '!=').tap { traverse(2) }
+            else
+              self.context = :ident
+              @buffer = c
+              traverse(1)
+            end
+          when *SYMBOLS.keys
+            return token(SYMBOLS[c], c).tap { traverse(1) }
+          when *WHITESPACE
+            traverse(1)
+          when *NEWLINES
+            traverse(1)
+            new_line
+          when INITIAL_IDENTIFIER_CHARS
+            self.context = :ident
+            @buffer = c
+            traverse(1)
+          when nil
+            return [false, nil]
+          else
+            raise_error "Unexpected `#{c}'"
+          end
+        when :ident
+          case c
+          when IDENTIFIER_CHARS
+            traverse(1)
+            @buffer += c
+          else
+            case @buffer
+            when 'true'  then return token(:TRUE, true)
+            when 'false' then return token(:FALSE, false)
+            when 'null'  then return token(:NULL, nil)
+            when 'top', 'name', 'tag', 'props', 'values'
+              if c == '(' && n == ')'
+                return token(@buffer.upcase.to_sym, "#{@buffer}()").tap { traverse(2) }
+              end
+            when 'val'
+              return token(:VAL, @buffer) if c == '('
+            when 'prop'
+              return token(:PROP, @buffer) if c == '('
+            end
+            return token(:IDENT, @buffer)
+          end
+        when :string
+          case c
+          when '\\'
+            @buffer += c
+            @buffer += @str[@index + 1]
+            traverse(2)
+          when '"'
+            return token(:STRING, convert_escapes(@buffer)).tap { traverse(1) }
+          when nil
+            raise_error 'Unterminated string literal'
+          else
+            @buffer += c
+            traverse(1)
+          end
+        when :number
+          case c
+          when /[0-9.\-+_eE]/
+            traverse(1)
+            @buffer += c
+          else
+            return parse_number(@buffer)
+          end
+        end
+      end
+    end
+
+    private
+
+    def token(type, value)
+      [type, Token.new(type, value, @line_at_start, @column_at_start)]
+    end
+
+    def traverse(count = 1)
+      @column += count
+      @index += count
+    end
+
+    def raise_error(message)
+      raise Error.new(message, @line, @column)
+    end
+
+    def new_line
+      @column = 1
+      @line += 1
+    end
+
+    def context=(new_context)
+      @previous_context = @context
+      @context = new_context
+    end
+
+    def parse_number(string)
+      return parse_float(string) if string =~ /[.E]/i
+
+      token(:INTEGER, Integer(munch_underscores(string), 10))
+    end
+
+    def parse_float(string)
+      string = munch_underscores(string)
+
+      value = Float(string)
+      if value.infinite? || (value.zero? && exponent.to_i < 0)
+        token(:FLOAT, BigDecimal(string))
+      else
+        token(:FLOAT, value)
+      end
+    end
+
+    def munch_underscores(string)
+      string.chomp('_').squeeze('_')
+    end
+
+    def convert_escapes(string)
+      string.gsub(/\\[^u]/) do |m|
+        case m
+        when '\n' then "\n"
+        when '\r' then "\r"
+        when '\t' then "\t"
+        when '\\\\' then '\\'
+        when '\"' then '"'
+        when '\b' then "\b"
+        when '\f' then "\f"
+        when '\/' then '/'
+        else raise_error "Unexpected escape #{m.inspect}"
+        end
+      end.gsub(/\\u\{[0-9a-fA-F]{0,6}\}/) do |m|
+        i = Integer(m[3..-2], 16)
+        if i < 0 || i > 0x10FFFF
+          raise_error "Invalid code point #{u}"
+        end
+        i.chr(Encoding::UTF_8)
+      end
+    end
+  end
+end

data/lib/kql/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module KQL
+  VERSION = "1.0.0"
+end

data/lib/kql.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+Class.module_eval do
+  def singleton(classname, superclass = nil, &block)
+    klass = Class.new(superclass, &block)
+    const_set(:"#{classname}Impl", klass)
+    const_set(classname, klass.new)
+  end
+end
+
+module KQL
+  def self.parse_query(query)
+    Parser.new.parse(query)
+  end
+
+  def self.query_document(document, query)
+    parse_query(query).execute(document)
+  end
+end
+
+require_relative "kql/version"
+require_relative "kql/tokenizer"
+require_relative "kql/query"
+require_relative "kql/filter"
+require_relative "kql/combinator"
+require_relative "kql/selector"
+require_relative "kql/matcher"
+require_relative "kql/accessor"
+require_relative "kql/operator"
+require_relative "kql/mapping"
+require_relative "kql/kql.tab"