plunk 0.2.11 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7c08aca732911470f0154ec5b6c12cdfcaa3876f
-  data.tar.gz: 9b0ffbfa317e102a4e44911d20d614cc50a3f17e
+  metadata.gz: bb14cb961c9f1fcfadaeefc60ca753cb061bf2eb
+  data.tar.gz: ee823ac07dfcb711d8d35becf70aea8a4f3cde05
 SHA512:
-  metadata.gz: 573e8a419a39a2b0e1fbed92b7c6a1c7bbe5388b19c17e789393d8726ffe5e75ada2872c89226ce869155b3361b749e18e4d8d5718b7d725a6edbf14f79a84f3
-  data.tar.gz: c5e897c8090906fc6d0ec9fbe9d0254eb3d95031397049fc71e7ef2537e39c5f0a5487b68589701190bb73ec03bfefa87da940f886470e2fe4f515904a8c8098
+  metadata.gz: d77fa8591e0c76809bbec4e24d408073836dd517bd35fad324ed389826fa02d4a989933e2fc1c71c5a61628dfea50c81416ca3e20333789b4a5e73a676c2810d
+  data.tar.gz: 6c76177d7f17f571f9f6ad46808ea6c99b0c2eadd4fc87256345e44d5111ebad5ca29171b5484676ad16ba3d13c1089c962c638a1d1016568616c2515afbc50f

data/AUTHORS

@@ -1,2 +1,3 @@
 Jamil Bou Kheir <jamil@elbii.com>
 Ram Mehta <ram.mehta@gmail.com>
+Roman Heinrich <roman.heinrich@gmail.com>

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    plunk (0.2.10)
+    plunk (0.3.1)
       activesupport
       elasticsearch
       json

data/lib/plunk.rb

@@ -1,5 +1,6 @@
 require 'elasticsearch'
 
+require 'plunk/helper'
 require 'plunk/utils'
 require 'plunk/parser'
 require 'plunk/transformer'
@@ -32,6 +33,10 @@ module Plunk
   end
 
   def self.search(query_string)
-    transformer.apply(parser.parse(query_string)).eval
+    ResultSet.new(
+      transformer.apply(
+        parser.parse(query_string)
+      )
+    ).eval
   end
 end

data/lib/plunk/helper.rb

@@ -0,0 +1,55 @@
+require 'active_support/core_ext'
+
+module Plunk
+  class Helper
+    def self.query_builder(query_string)
+      {
+        query: {
+          query_string: {
+            query: query_string
+          }
+        }
+      }
+    end
+
+    def self.filter_builder(filter)
+      {
+        query: {
+          filtered: {
+            filter: filter
+          }
+        }
+      }
+    end
+
+    def self.range_builder(range_min, range_max)
+      {
+        range: {
+          Plunk.timestamp_field => {
+            gte: range_min,
+            gte: range_max
+          }
+        }
+      }
+    end
+
+    def self.time_query_to_timestamp(int_quantity, quantifier)
+      case quantifier
+      when 's'
+        int_quantity.seconds.ago
+      when 'm'
+        int_quantity.minutes.ago
+      when 'h'
+        int_quantity.hours.ago
+      when 'd'
+        int_quantity.days.ago
+      when 'w'
+        int_quantity.weeks.ago
+      end
+    end
+
+    def self.timestamp_format(time)
+      time.utc.to_datetime.iso8601(3)
+    end
+  end
+end

data/lib/plunk/parser.rb

@@ -3,14 +3,11 @@ require 'parslet'
 module Plunk
   class Parser < Parslet::Parser
 
-    def parenthesized(atom)
-      lparen >> atom >> rparen
-    end
+    # BUILDING BLOCKS
 
     # Single character rules
     rule(:lparen)     { str('(') >> space? }
     rule(:rparen)     { str(')') >> space? }
-    rule(:comma)      { str(',') >> space? }
     rule(:digit)      { match('[0-9]') }
     rule(:space)      { match('\s').repeat(1) }
     rule(:space?)     { space.maybe }
@@ -21,6 +18,8 @@ module Plunk
       str('-').maybe >> digit.repeat(1) >> str('.') >> digit.repeat(1) >> space?
     }
     rule(:number)     { integer | float }
+
+    # Dates
     rule(:datetime) {
       # 1979-05-27T07:32:00Z
       digit.repeat(4) >> str("-") >> 
@@ -30,10 +29,11 @@ module Plunk
       digit.repeat(2) >> str(":") >> 
       digit.repeat(2) >> str("Z")
     }
+
+    # Strings
     rule(:escaped_special) {
       str("\\") >> match['0tnr"\\\\']
     }
-
     rule(:string_special) {
       match['\0\t\n\r"\\\\']
     }
@@ -43,79 +43,101 @@ module Plunk
       str('"')
     }
 
-    # Field / value
-    rule(:identifier) { match('[^=\s)(|]').repeat(1) >> match('[^=\s]').repeat }
-    # possible right-hand side values
-    rule(:wildcard)   { match('[^=\s)(|]').repeat(1) }
-    rule(:searchop)   { match('[=]').as(:op) }
+    # Booleans
+    rule(:and_operator) { (str('and') | str('AND') | str('&')) >> space? }
+    rule(:or_operator)  { (str('or') | str('OR') | str('|'))  >> space? }
+    rule(:not_operator) { (str('not') | str('NOT') | str('~')) >> space? }
 
-    rule(:query_value) { string | wildcard | datetime | number }
 
-    # boolean operators search
-    rule(:concatop)   { (str('OR') | str('AND')) >> space? }
-    rule(:negateop)   { str('NOT') >> space? }
-    rule(:operator)   { match('[|]').as(:op) >> space? }
-    rule(:timerange)  {
-      integer.as(:quantity) >> match('s|m|h|d|w').as(:quantifier)
-    }
+    # COMMANDS
 
-    # Grammar parts
-    rule(:rhs) {
-      regexp | subsearch | booleanop
+    # Command parts
+    rule(:identifier) { match('[^=\s)(|]').repeat(1) >> match('[^=\s]').repeat }
+    rule(:wildcard)   {
+      (lparen >> wildcard >> rparen) |
+      match('[^=\s|)(]').repeat(1)
     }
-
-    rule(:boolean_value) {
-      booleanparen | (negateop.maybe >> query_value)
+    rule(:query_value) { string | wildcard | datetime | number }
+    rule(:searchop)   { match['='] }
+    rule(:rhs) {
+      regexp | query_value
     }
 
-    # AND, OR
-    rule(:boolean_logic) {
-      space >> concatop >> boolean_value
+    # Field = Value
+    rule(:field_value) {
+      identifier.as(:field) >> space? >>
+      searchop >> space? >>
+      (rhs.as(:value) | subsearch.as(:subsearch))
     }
 
-    # handles recursion for parentheses and values
-    rule(:booleanop) {
-      boolean_value >> boolean_logic.repeat
-    }
-    rule(:booleanparen) {
-      lparen >> space? >> booleanop >> space? >> rparen
+    # Value-only
+    rule(:value_only) {
+      rhs.as(:value)
     }
 
+    # Regexp
     rule(:regexp) {
       str('/') >> (str('\/') | match('[^/]')).repeat >> str('/')
     }
 
+    # Last
     rule(:last) {
-      str("last") >> space >> timerange.as(:timerange) >> (space >>
-      search.as(:search)).maybe
-    }
-
-    rule(:search) {
-      identifier.as(:field) >> space? >> searchop >> space? >>
-        rhs.as(:value) | rhs.as(:match)
+      str('last') >>
+      space >>
+      integer.as(:quantity) >>
+      match('s|m|h|d|w').as(:quantifier)
     }
 
+    # Subsearch
     rule(:subsearch) {
       str('`') >> space? >> nested_search >> str('`')
     }
-
     rule(:nested_search) {
-      job.as(:initial_query) >> space? >> str('|') >> space? >>
+      plunk_query.as(:initial_query) >> space? >> str('|') >> space? >>
       match('[^`]').repeat.as(:extractors)
     }
 
-    rule(:paren) {
-      lparen >> space? >> job >> space? >> rparen
+    # Reference your custom commands here to make them eligible for parsing
+    # NOTE: order matters!
+    rule(:command) {
+      (
+        last        |
+        field_value |
+        value_only
+      ).as(:command) >> space?
     }
 
-    rule(:job) {
-      last | search | paren
+
+    # QUERY JOINING
+ 
+    rule(:negated_command) {
+      (not_operator >> command.as(:not)) |
+      command
+    }
+    rule(:primary) { lparen >> or_operation >> rparen | negated_command }
+
+    rule(:negated_and) {
+      (not_operator >> and_operation.as(:not)) |
+      and_operation
+    }
+    rule(:and_operation) { 
+      (primary.as(:left) >> and_operator >> 
+        negated_and.as(:right)).as(:and) | 
+      primary }
+      
+    rule(:negated_or) {
+      (not_operator >> or_operation.as(:not)) |
+      or_operation
     }
+    rule(:or_operation)  { 
+      (and_operation.as(:left) >> or_operator >> 
+        negated_or.as(:right)).as(:or) | 
+      and_operation }
 
     rule(:plunk_query) {
-      space? >> job >> (space >> job).repeat >> space?
+      space? >> or_operation >> space?
     }
 
-    root :plunk_query
+    root(:plunk_query)
   end
 end

data/lib/plunk/result_set.rb

@@ -2,60 +2,15 @@ module Plunk
   class ResultSet
     attr_accessor :query, :query_string
 
-    def initialize(opts={})
-      @query = { query: { filtered: {}}}
-
-      if opts.size >= 3 # use "and" filter to AND filters
-        @query_string = opts[:query_string]
-        @query[:query][:filtered][:query] = {
-          query_string: {
-            query: opts[:query_string] }}
-        @query[:query][:filtered][:filter] = {
-          and: [
-            range: {
-              Plunk.timestamp_field => {
-                gte: opts[:start_time],
-                lte: opts[:end_time] }}]}
-      else
-        if @query_string = opts[:query_string]
-          @query[:query][:filtered][:query] = {
-            query_string: {
-              query: opts[:query_string] }}
-        elsif opts[:start_time] and opts[:end_time]
-          @query[:query][:filtered][:query] = {
-            range: {
-              Plunk.timestamp_field => {
-                gte: opts[:start_time],
-                lte: opts[:end_time] }}}
-        end
-      end
+    def initialize(filter)
+      @query = { query: { filtered: { filter: filter }}}
     end
 
     def eval
       Plunk.elasticsearch_client.search(
-        body: @query.to_json,
+        body: @query,
         size: Plunk.max_number_of_hits || 10
-      ).to_json if @query
-    end
-
-    # merges multiple queries with implicit AND
-    def self.merge(result_sets)
-      first = result_sets.delete_at 0
-
-      first.query[:query][:filtered][:filter] ||= {}
-      first.query[:query][:filtered][:filter][:and] ||= []
-
-      result_sets.each do |result_set|
-        first.query[:query][:filtered][:filter][:and] <<
-          result_set.query[:query][:filtered]
-
-        if result_set.query[:query][:filtered][:filter]
-          first.query[:query][:filtered][:filter][:and] +=
-            result_set.query[:query][:filtered][:filter][:and]
-        end
-      end
-
-      first
+      ) if @query
     end
   end
 end

data/lib/plunk/transformer.rb

@@ -1,135 +1,54 @@
 require 'parslet'
-require 'active_support/core_ext'
 
 module Plunk
-
-  class Helper
-    def self.time_query_to_timestamp(int_quantity, quantifier)
-      case quantifier
-      when 's'
-        int_quantity.seconds.ago
-      when 'm'
-        int_quantity.minutes.ago
-      when 'h'
-        int_quantity.hours.ago
-      when 'd'
-        int_quantity.days.ago
-      when 'w'
-        int_quantity.weeks.ago
-      end
-    end
-
-    def self.timestamp_format(time)
-      time.utc.to_datetime.iso8601(3)
-    end
-
-    def self.time_range_hash(start_time, end_time)
-      {
-        start_time: Plunk::Helper.timestamp_format(start_time),
-        end_time: Plunk::Helper.timestamp_format(end_time)
-      }
-    end
-  end
-
   class Transformer < Parslet::Transform
 
-    # last 24h foo=bar
-    rule(
+    # Field = Value
+    rule(command: {
       field: simple(:field),
-      value: {
-        initial_query: subtree(:initial_query),
-        extractors: simple(:extractors)
-      },
-      op: '=',
-      timerange: {
-        quantity: simple(:quantity),
-        quantifier: simple(:quantifier)
-      }) do
-
-      int_quantity = quantity.to_s.to_i
-      start_time   = Plunk::Helper.time_query_to_timestamp(int_quantity, quantifier)
-      end_time     = Time.now
-
-      # recursively apply nested query
-      result_set = Plunk::Transformer.new.apply(initial_query)
-
-      json = JSON.parse result_set.eval
-      values = Plunk::Utils.extract_values json, extractors.to_s.split(',')
-
-      result_set_params = Plunk::Helper.time_range_hash(start_time, end_time)
-      if values.empty?
-        result_set_params.merge!(query_string: "#{field}:(#{values.uniq.join(' OR ')})",)
-      end
-      Plunk::ResultSet.new(result_set_params)
+      value: simple(:value)
+    }) do
+      Helper.query_builder(
+        String(field) + ":" + String(value)
+      )
     end
 
-    rule(match: simple(:value)) do
-      ResultSet.new(query_string: "#{value}")
+    # Value-only
+    rule(command: { value: simple(:value) }) do
+      Helper.query_builder(String(value))
     end
 
-    # foo=`bar=baz|field1,field2,field3`
-    rule(
-      field: simple(:field),
-      value: {
-        initial_query: subtree(:initial_query),
-        extractors: simple(:extractors)
-      },
-      op: '=') do
-
-      # recursively apply nested query
-      result_set = Transformer.new.apply(initial_query)
-
-      json = JSON.parse result_set.eval
-      values = Utils.extract_values json, extractors.to_s.split(',')
+    rule(command: {
+      quantity: simple(:quantity),
+      quantifier: simple(:quantifier)
+    }) do
+      start_timestamp = Helper.time_query_to_timestamp(
+        Integer(quantity),
+        String(quantifier)
+      )
 
-      if values.empty?
-        ResultSet.new
-      else
-        ResultSet.new(query_string: "#{field}:(#{values.uniq.join(' OR ')})")
-      end
-    end
+      start_time = Helper.timestamp_format start_timestamp
+      end_time = Helper.timestamp_format(Time.now)
 
-    # foo=bar
-    rule(field: simple(:field), value: simple(:value), op: '=') do
-      ResultSet.new(query_string: "#{field}:#{value}")
+      Helper.range_builder(start_time, end_time)
     end
 
-    rule(
-      timerange: {
-        quantity: simple(:quantity),
-        quantifier: simple(:quantifier)
-      }) do
-
-      int_quantity = quantity.to_s.to_i
-      start_time   = Plunk::Helper.time_query_to_timestamp(int_quantity, quantifier)
-      end_time     = Time.now
-
-      result_set_params = Plunk::Helper.time_range_hash(start_time, end_time)
-      Plunk::ResultSet.new(result_set_params)
+    rule(:negate => subtree(:not)) do
+      { not: negate }
     end
 
-    # last 24h
-    rule(
-      search: simple(:result_set),
-      timerange: {
-        quantity: simple(:quantity),
-        quantifier: simple(:quantifier)
-      }) do
-
-      int_quantity = quantity.to_s.to_i
-      start_time   = Plunk::Helper.time_query_to_timestamp(int_quantity, quantifier)
-      end_time     = Time.now
-
-      result_set_params = Plunk::Helper.time_range_hash(start_time, end_time)
-      result_set_params.merge!(query_string: result_set.query_string)
-      Plunk::ResultSet.new(result_set_params)
+    rule(:or => {
+      left: subtree(:left),
+      right: subtree(:right)
+    }) do
+      { or: [left, right] }
     end
 
-    # last 24h foo=bar baz=fez
-    rule(
-      sequence(:set)
-    ) do
-      Plunk::ResultSet.merge(set)
+    rule(:and => {
+      left: subtree(:left),
+      right: subtree(:right)
+    }) do
+      { and: [left, right] }
     end
   end
 end