ddql 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '038be470281a3216e90884f9b14e2f30c087494906a79089d7dff5ea32bdd29a'
-  data.tar.gz: 812b0f99b1b1f2c84bddf6ebbe0abfeecdbdbfc47d036c3d65d5a0234b961f8d
+  metadata.gz: a257ea91453ff55380b71ef1a98e0a4b32d9688ee87b9f6d74e5141d58e73424
+  data.tar.gz: e6eae8733865abfb13efc7d2e252cb0a1c7b3ee1afbe2a7445248a1adef66c98
 SHA512:
-  metadata.gz: c313fd79cb88f08c98af30190e24d52a66e05365c02e29a6c1900d77bef056443f3db18bf3e204b81bdcaa0cefb4e00b778cad159c53c3cee6b9d4ddc775d76b
-  data.tar.gz: ced003fd8bcd3fa2b7a9e828fa76d01e101109b9eca210778b9283e226004cc4803a17f15b763ab8659a3d07506add93d28be0078fd11c15e5c04f290dc10345
+  metadata.gz: d539c78fd753b66f5303d5d1941b75e52e8a3a77c3c506823c73aa15b8a79804d23e5e54472c28888038d5073e3a4f0dc493b934b0f6dba6e9b660077eab5474
+  data.tar.gz: b94754405933f0607ca4412b02219df659c2068b52cac3f4d2c2db18fc7b5d246d84131bc0af665fd8b81eb2ac74c022ef0474bc5b1f9cd717e9bdda5d64d41c

data/.ruby-version

@@ -1 +1 @@
-ruby-2.6.3
+ruby-2.7.2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ddql (1.0.0)
+    ddql (1.0.1)
 
 GEM
   remote: https://rubygems.org/
@@ -9,36 +9,36 @@ GEM
     byebug (11.1.3)
     coderay (1.1.3)
     diff-lcs (1.4.4)
-    ffi (1.13.1-java)
+    ffi (1.15.3-java)
     method_source (0.9.2)
-    pry (0.11.3)
+    pry (0.12.2)
       coderay (~> 1.1.0)
       method_source (~> 0.9.0)
-    pry (0.11.3-java)
+    pry (0.12.2-java)
       coderay (~> 1.1.0)
       method_source (~> 0.9.0)
       spoon (~> 0.0)
     pry-byebug (3.8.0)
       byebug (~> 11.0)
       pry (~> 0.10)
-    pry-debugger-jruby (1.2.1-java)
-      pry (>= 0.10, < 0.12)
-      ruby-debug-base (~> 0.10.4)
-    rake (13.0.1)
-    rspec (3.9.0)
-      rspec-core (~> 3.9.0)
-      rspec-expectations (~> 3.9.0)
-      rspec-mocks (~> 3.9.0)
-    rspec-core (3.9.2)
-      rspec-support (~> 3.9.3)
-    rspec-expectations (3.9.2)
+    pry-debugger-jruby (1.2.2-java)
+      pry (>= 0.10, < 0.13)
+      ruby-debug-base (>= 0.10.4, < 0.12)
+    rake (13.0.3)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-mocks (3.9.1)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-support (3.9.3)
-    ruby-debug-base (0.10.6-java)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+    ruby-debug-base (0.11.0-java)
     spoon (0.0.6)
       ffi
 

data/lib/ddql.rb

@@ -1,10 +1,11 @@
 require 'ddql/version'
+require_relative 'ddql/blank_refinements'
+require_relative 'ddql/string_refinements'
 require_relative 'ddql/linked_list'
 require_relative 'ddql/query_expression_error'
 require_relative 'ddql/lexer'
 require_relative 'ddql/operators'
 require_relative 'ddql/parser'
-require_relative 'ddql/string_refinements'
 require_relative 'ddql/token_type'
 require_relative 'ddql/token'
 

data/lib/ddql/agg_operator.rb

@@ -1,4 +1,6 @@
 module DDQL
+  using StringRefinements
+
   # +AggOperators+ return a Hash structure describing the type of aggregation, an optional
   # expression (filter) to apply, an optional factor (field) against which the aggregation
   # is applied, and the entity type for which the aggregation is applicable.
@@ -13,7 +15,7 @@ module DDQL
   #        sub_query_type: 'IssuerPerson',
   #      }
   #
-  #    +CNT{type:Issuer, expression: [SomeFactor]} / CNT{type:Issuer, expression: [OtherFactor]}+
+  #    +CNT{type:Issuer, fields: [SomeFactor]} / CNT{type:Issuer, fields: [OtherFactor]}+
   #
   #      {
   #        left: {
@@ -29,7 +31,7 @@ module DDQL
   #        },
   #      }
   #
-  #    +MAX{type:Case, expression: [SomeFactor]} > 5+
+  #    +MAX{type:Case, fields: [SomeFactor]} > 5+
   #
   #      {
   #        left: {
@@ -40,7 +42,18 @@ module DDQL
   #        op: {op_gt: '>'},
   #        right: {int: 5},
   #      }
+  #
+  #    +ALIAS{type:Issuer, expression: [SomeFactor] > 5} AS [ThatFactor:That Factor]+
+  #
+  #      {
+  #         agg: {op_max: 'ALIAS'},
+  #         sub_query_type: 'Issuer',
+  #         sub_query_expression: '[SomeFactor] > 5',
+  #         sub_query_alias: {factor: 'ThatFactor', desc: 'That Factor'},
+  #      }
   class AggOperator < Operator
+    using BlankRefinements
+
     def initialize(symbol, name, return_type:, type: :prefix, precedence: 8, right: false)
       super(symbol, name, type, precedence, right, return_type)
     end
@@ -52,24 +65,69 @@ module DDQL
       else
         expression = new_expression
       end
+
       expression.merge!(agg: {:"op_#{symbol.downcase}" => symbol})
+      if parser.peek&.supports_post_processing?
+        token, expression = parser.peek.post_process(parser: parser, expression: expression)
+      end
+      as_agg(expression)
+    end
+
+    def as_left_op_right(expression)
+      new_expression = {
+        agg: expression.delete(:agg),
+        sub_query_type: expression.delete(:sub_query_type),
+        sub_query_fields: expression.delete(:sub_query_fields),
+        sub_query_expression: expression.delete(:sub_query_expression),
+      }.compact
 
-      if expression.key?(:op) && expression.key?(:right)
-        if expression[:left]&.empty?
-          expression.delete :left
+      if expression[:lstatement].key?(:op) && expression[:lstatement][:left].blank?
+        {
+          left: new_expression,
+          op: expression[:lstatement][:op],
+          right: expression[:lstatement][:right],
+        }
+      elsif expression[:lstatement].key?(:lstatement)
+        if expression[:lstatement][:lstatement].empty?
+          expression[:lstatement][:lstatement] = new_expression
+          expression[:lstatement]
+        else
+          final_expression = expression[:lstatement]
+          final_expression[:lstatement][:left] = new_expression
+          final_expression
         end
-        op = expression.delete :op
-        right = expression.delete :right
+      else
+        new_expression
+      end
+    end
+
+    def as_agg(expr)
+      expression = expr.dup
+      if expression.key?(:yes_no_op)
+        # AGG Y/N
+        yes_no_op = expression.delete(:yes_no_op)
+        {
+          left: expression,
+          yes_no_op: yes_no_op,
+        }
+      elsif expression.key?(:op)
+        # AGG COMP LIT
+        expression.delete(:left)
+        op = expression.delete(:op)
+        right = expression.delete(:right)
         {
           left: expression,
           op: op,
           right: right,
         }
-      elsif expression.key?(:yes_no_op)
-        yes_no = expression.delete :yes_no_op
+      elsif expression.key?(:boolean_operator)
+        # AGG BOOL STMT
+        bool_op = expression.delete(:boolean_operator)
+        rstatement = expression.delete(:rstatement)
         {
-          left: expression,
-          yes_no_op: yes_no,
+          lstatement: as_left_op_right(expression),
+          boolean_operator: bool_op,
+          rstatement: rstatement,
         }
       else
         expression

data/lib/ddql/blank_refinements.rb

@@ -0,0 +1,21 @@
+module DDQL
+  module BlankRefinements
+    refine Enumerable do
+      def blank?
+        empty? || compact.empty?
+      end
+    end
+
+    refine Hash do
+      def blank?
+        empty? || compact.empty?
+      end
+    end
+
+    refine NilClass do
+      def blank?
+        true
+      end
+    end
+  end
+end

data/lib/ddql/coalesce_operator.rb

@@ -13,13 +13,12 @@ module DDQL
       end
 
       left_factor, right_factor = expression[:string].split('|', 2)
+
       {
-        op_coalesce: {
-          factors: {
-            left_factor: {factor: left_factor},
-            right_factor: {factor: right_factor},
-          },
-        }
+        op_coalesce: [
+          {factor: left_factor},
+          {factor: right_factor},
+        ]
       }
     end
   end

data/lib/ddql/infix_float_map_operator.rb

@@ -2,8 +2,8 @@ module DDQL
   class InfixFloatMapOperator < Operator
     attr_reader :comparison, :op_type, :op_symbol
 
-    def initialize(symbol, name, ordinal, op_type, comparison)
-      super(symbol, name, :infix, 4, false, :boolean, ordinal)
+    def initialize(symbol, name, op_type, comparison)
+      super(symbol, name, :infix, 4, false, :boolean)
       @op_type    = op_type
       @comparison = comparison
       @op_symbol  = :"op_float_map_#{op_type}_#{comparison}"

data/lib/ddql/infix_string_map_operator.rb

@@ -1,7 +1,7 @@
 module DDQL
   class InfixStringMapOperator < Operator
-    def initialize(symbol, name, ordinal)
-      super(symbol, name, :infix, 4, false, :boolean, ordinal)
+    def initialize(symbol, name)
+      super(symbol, name, :infix, 4, false, :boolean)
     end
   end
 end

data/lib/ddql/linked_list.rb

@@ -2,13 +2,16 @@ module DDQL
   class LinkedList
     include Enumerable
 
+    class NavigationError < StandardError
+    end
+
     class Node
       attr_accessor :next, :previous
       attr_reader   :value
 
-      def initialize(value)
-        @next     = nil
-        @previous = nil
+      def initialize(value, next_node: nil, previous_node: nil)
+        @next     = next_node
+        @previous = previous_node
         @value    = value
       end
 
@@ -22,61 +25,110 @@ module DDQL
     def initialize(head=nil)
       @doubly_linked = false
       @head          = head
-      @size          = 0
+      @size          = head.nil? ? 0 : 1
+      @tail          = @head
     end
 
     def append(value)
       if @head
         tail = find_tail
-        tail.next = Node.new(value)
-        tail.next.previous = tail if @doubly_linked
+        if Node === value
+          value.previous = tail if @doubly_linked
+          tail.next = value
+        else
+          tail.next = Node.new(value)
+          tail.next.previous = tail if @doubly_linked
+        end
+        @tail = tail.next
       else
-        @head = Node.new(value)
+        @head = @tail = Node === value ? value : Node.new(value)
       end
       @size += 1
     end
     alias :<< :append
 
+    # Insert the +value+ after the +target+
+    #
+    # @return [Node|NilClass] nil if +target+ is not found, otherwise the inserted node for +value+
     def append_after(target, value)
-      node           = find(target)
+      node = find(target)
       return unless node
-      old_next       = node.next
-      node.next      = Node.new(value)
-      node.next.next = old_next
-    end
-
-    def doubly_linked!
-      current = nil
-      each_node do |node|
-        node.previous = current
-        current = node
+      old_next = node.next
+      if @doubly_linked
+        if Node === value
+          value.previous = node
+          value.next     = old_next
+          node.next      = value
+        else
+          node.next = Node.new(value, previous_node: node, next_node: old_next)
+        end
+      elsif Node === value
+        value.next = old_next
+        node.next  = value
+      else
+        node.next = Node.new(value, next_node: old_next)
       end
-      @doubly_linked = true
-      self
+      @tail = node.next if old_next.nil?
+      node.next
     end
+    alias :insert :append_after
 
-    def doubly_linked?
-      @doubly_linked
+    def at(index)
+      return nil if index < 0 || index >= size
+      return @head if index == 0
+      return @tail if index == size - 1
+
+      current_index = 0
+      current_node  = head
+      while current_node = current_node.next
+        current_index += 1
+        return current_node if current_index == index
+      end
     end
+    alias :[] :at
 
     def delete(value)
       if value.is_a?(Node) && @head == value
         @head = @head.next
         value.next = value.previous = nil
+        @tail = @head if @head.nil? || @head.next.nil?
       elsif @head.value == value
         node = @head.next
         @head.next = @head.previous = nil
         value = @head
         @head = node
+        @tail = @head if @head.next.nil?
       else
         node = find_before(value)
+
+        if node && node.next == tail
+          @tail = node
+          node.next = nil
+        end
+
         node.next = node.next.next if node && node.next
-        node.next = node.previous = nil if node
+        node.next.previous = node if doubly_linked! && node.next
       end
       @size -= 1
       value
     end
 
+    def doubly_linked!
+      return self if doubly_linked?
+
+      current = nil
+      each_node do |node|
+        node.previous = current
+        current = node
+      end
+      @doubly_linked = true
+      self
+    end
+
+    def doubly_linked?
+      @doubly_linked
+    end
+
     def each
       return to_enum unless block_given?
       node = @head
@@ -86,13 +138,28 @@ module DDQL
       end
     end
 
-    def find(value)
+    def empty?
+      @size == 0
+    end
+
+    def find(value=nil, &blk)
       node = @head
       is_node = value.is_a?(Node)
-      return false if !node.next
-      return node  if (is_node && node == value) || node.value == value
+      return false if !node.next && (!blk || (blk && !yield(node)))
+      return node  if (is_node && node == value) || node.value == value || (blk && yield(node))
       while (node = node.next)
-        return node if (is_node && node == value) || node.value == value
+        return node if (is_node && node == value) || node.value == value || (blk && yield(node))
+      end
+    end
+
+    def find_from_tail(value=nil, &blk)
+      raise NavigationError, "singly-linked lists don't support finding nodes from the tail" unless doubly_linked?
+      node = @tail
+      is_node = value.is_a?(Node)
+      return false if !node.previous && (!blk || (blk && !yield(node)))
+      return node  if (is_node && node == value) || node.value == value || (blk && yield(node))
+      while (node = node.previous)
+        return node if (is_node && node == value) || node.value == value || (blk && yield(node))
       end
     end
 
@@ -113,9 +180,12 @@ module DDQL
     end
 
     def find_tail
-      node = @head
-      return node if !node.next
-      return node if !node.next while (node = node.next)
+      if @tail.nil?
+        node = @head
+        return @tail = node if !node.next
+        return @tail = node if !node.next while (node = node.next)
+      end
+      @tail
     end
     alias :tail :find_tail
 
@@ -150,6 +220,40 @@ module DDQL
       end
     end
 
+    # Replace a range of nodes from +from+ to +to+, inclusive,
+    # with the given +with+. +from+, +to+, and +with+ can all
+    # be values or nodes.
+    #
+    # @return self
+    def replace!(from:, to:, with:)
+      first_node = find(from)
+      last_node  = find(to)
+      tail       = find_tail
+      raise 'cannot find appropriate range for replacement' if first_node.nil? || last_node.nil?
+
+      replacement = Node === with ? with : Node.new(with)
+      if first_node == head
+        @head = replacement
+        unless last_node == tail
+          new_tail          = last_node.next
+          replacement.next  = new_tail
+          new_tail.previous = replacement if doubly_linked?
+        end
+        return self
+      end
+
+      if doubly_linked?
+        replacement.previous      = first_node.previous
+        replacement.previous.next = replacement
+        last_node.next.previous   = replacement
+      elsif first_node != head
+        previous = find_before(first_node)
+        previous.next = replacement
+      end
+      replacement.next = last_node.next
+      self
+    end
+
     def singly_linked!
       each_node do |node|
         node.previous = nil