command_search 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0fcd48aa860c52997a4d321cbd60da14cf1655a7def93428da30ab593992a25
-  data.tar.gz: '093079892f0bb5dfeb7dc0e041349e106a791a4e0dfcc94a66fff0e4100c7058'
+  metadata.gz: 1ab34234037969a83820730a8a209e1fe0ca29ed9a2b34f1f1c3f0a72b570b5c
+  data.tar.gz: f3c4af7b842ae0a59057a2d700bb9c39b739c96fe18248377deecdc38c70aede
 SHA512:
-  metadata.gz: 5d2638ace20b629f1e4ff71358e2573293d3e08c397a216479eefb3f5a995f50d84b14cfcfafbc1c4d8c76bb48a45cc8cb20a2aa300ac7f3dfca7809396ae3c8
-  data.tar.gz: db0bc500aa61bda6dcb1f28c29b1822b1fcfb0b712c708aecb4b4badfcd72b840f42c3a1e90ae60efa84784cc800ccf5e7372289b1dd2e8702dc57b5541dc054
+  metadata.gz: d1e7ffc036d37d54217a78184a2c18705ad85529cad90e75851c6512d10a0214d22d083da7cf504eed6257bc28576c885a56dd383bc4e37cb39919ac1e8e665d
+  data.tar.gz: d4ce49e9747f21e06ced4884b4a72f03c6c335ab9d20e91f7e6ebd985a3a9cbca11dc0cacf1422d0ced8f4d322b9b48f95327099769030fa820eade6da4f5d7c

data/lib/command_search/lexer.rb

@@ -9,31 +9,27 @@ module CommandSearch
         match = nil
         case input[i..-1]
         when /^\s+/
-          i += Regexp.last_match[0].length
-          next
+          type = :space
         when /^"(.*?)"/
           match = Regexp.last_match[1]
           type = :quoted_str
         when /^'(.*?)'/
           match = Regexp.last_match[1]
           type = :quoted_str
-        when /^\-?\d+(\.\d+)?(?=$|[\s"':|<>)(])/
+        when /^\-?\d+(\.\d+)?(?=$|[\s"':|<>()])/
           type = :number
-        when /^\|+/
-          type = :pipe
         when /^-/
           type = :minus
-        when /^:/
-          type = :colon
+        when /^[^\s:"|<>()]+/
+          type = :str
+        when /^\|+/
+          type = :pipe
         when /^[()]/
           type = :paren
+        when /^:/
+          type = :colon
         when /^[<>]=?/
           type = :compare
-        # when /^([^\s"|<>()]+):/
-        #   match = Regexp.last_match[1]
-        #   type = :command
-        when /^[^\s:"|<>()]+/
-          type = :str
         when /^./
           type = :str
         end

data/lib/command_search/parser.rb

@@ -4,9 +4,9 @@ module CommandSearch
 
     def parens_rindex(input)
       val_list = input.map { |x| x[:value] }
-      open_i = val_list.rindex('(')
+      open_i = input.rindex { |x| x[:value] == '(' && x[:type] == :paren}
       return unless open_i
-      close_offset = val_list.drop(open_i).index(')')
+      close_offset = input.drop(open_i).index { |x| x[:value] == ')' && x[:type] == :paren}
       return unless close_offset
       [open_i, close_offset + open_i]
     end
@@ -46,40 +46,81 @@ module CommandSearch
       end
     end
 
-    def unchain!(type, input)
-      (input.length - 2).times do |i|
+    def unchain!(types, input)
+      i = 0
+      while i < input.length - 2
         front = input[i][:type]
         mid = input[i + 1][:type]
         back = input[i + 2][:type]
-        if front == type && mid != type && back == type
+        if types.include?(front) && !types.include?(mid) && types.include?(back)
           input.insert(i + 1, input[i + 1])
         end
+        i += 1
       end
     end
 
-    def clean_ununused_syntax(input)
-      out = input.map do |x|
+    def merge_strs(input, (x, y))
+      return input if input.empty?
+      if input[y] && input[y][:type] == :str
+        values = input.map { |x| x[:value] }
+        { type: :str, value: values.join() }
+      else
+        input[x][:type] = :str
+        input
+      end
+    end
+
+    def clean_ununusable!(input)
+      return unless input.any?
+
+      i = 0
+      while i < input.length
+        next i += 1 unless input[i][:type] == :minus
+        next i += 1 unless i > 0 && [:compare, :colon].include?(input[i - 1][:type])
+        input[i..i + 1] = merge_strs(input[i..i + 1], [0, 1])
+      end
+
+      i = 0
+      while i < input.length
+        next i += 1 if ![:compare, :colon].include?(input[i][:type])
+        next i += 1 if i > 0 &&
+          (i < input.count - 1) &&
+          [:str, :number, :quoted_str].include?(input[i - 1][:type]) &&
+          [:str, :number, :quoted_str].include?(input[i + 1][:type])
+
+        input[i..i + 1] = merge_strs(input[i..i + 1], [0, 1])
+        input[i - 1..i] = merge_strs(input[i - 1..i], [1, 0]) if i > 0
+      end
+
+      input.select! { |x| x[:type] != :space }
+      input[-1][:type] = :str if input[-1] && input[-1][:type] == :minus
+    end
+
+    def clean_ununused!(input)
+      input.map! do |x|
         next if x[:type] == :paren && x[:value].is_a?(String)
         next if x[:nest_type] == :colon && x[:value].empty?
         if x[:nest_type] == :compare && x[:value].length < 2
-          x = clean_ununused_syntax(x[:value]).first
+          x = clean_ununused!(x[:value]).first
         end
         next x unless x && x[:type] == :nest
-        x[:value] = clean_ununused_syntax(x[:value])
+        x[:value] = clean_ununused!(x[:value])
         x
       end
-      out.compact
+      input.compact!
+      input
     end
 
     def parse(input)
       out = input
+      clean_ununusable!(out)
+      unchain!([:colon, :compare], out)
       out = group_parens(out)
       cluster!(:colon, out)
-      unchain!(:compare, out)
       cluster!(:compare, out)
       cluster!(:minus, out, :prefix)
       cluster!(:pipe, out)
-      out = clean_ununused_syntax(out)
+      clean_ununused!(out)
       out
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: command_search
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - zumbalogy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-03 00:00:00.000000000 Z
+date: 2018-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chronic
@@ -58,7 +58,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 3.0.0.beta1
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Let users query collections with ease.