ruby-zoom 4.7.5 → 5.0.0

data/lib/zoom.rb

@@ -5,6 +5,77 @@ class Zoom
     attr_reader :cache
     attr_reader :config
 
+    def ensure_valid_header(header)
+        # Ensure header has no nil
+        header["args"] ||= ""
+        header["debug"] ||= false
+        header["paths"] ||= "."
+        header["paths"] = "." if (header["paths"].empty?)
+        header["profile_name"] ||= ""
+        header["pwd"] = Dir.pwd
+        header["regex"] ||= ""
+        header["translate"] ||= Hash.new
+
+        # If no profile name, use the current profile
+        profile_name = header["profile_name"]
+        if (profile_name.empty?)
+            profile_name = @config.current_profile_name
+            header["profile_name"] = profile_name
+        end
+
+        if (!@config.has_profile?(profile_name))
+            raise Zoom::Error::ProfileDoesNotExist.new(profile_name)
+        end
+
+        profile = @config.get_profile(profile_name)
+
+        # Use hard-coded regex if defined
+        if (
+            profile.regex &&
+            !profile.regex.empty? &&
+            (header["regex"] != profile.regex)
+        )
+            # If there was a regex then it may be an arg or a path
+            if (!header["regex"].empty?)
+                if (Pathname.new(header["regex"]).exist?)
+                    header["paths"] = "" if (header["paths"] == ".")
+                    paths = header["paths"].split(" ")
+                    paths.insert(0, header["regex"])
+                    header["paths"] = paths.join(" ")
+                else
+                    header["args"] += " #{header["regex"]}"
+                end
+            end
+
+            header["regex"] = profile.regex
+        end
+
+        # If using a search tool
+        if (!profile.format_flags.empty?)
+            if (header["regex"].empty? && header["paths"] == ".")
+                # Throw exception because no regex was provided or
+                # hard-coded
+                raise Zoom::Error::RegexNotProvided.new
+            end
+
+            # This isn't done here anymore as it breaks stuff
+            # header["regex"] = header["regex"].shellescape
+        end
+
+        # Strip values
+        header.keys.each do |key|
+            next if (key == "regex")
+            begin
+                header[key].strip!
+            rescue
+                # Wasn't a String
+            end
+        end
+
+        return header
+    end
+    private :ensure_valid_header
+
     def self.hilight(hilight = true)
         @@hilight = hilight
     end
@@ -22,10 +93,7 @@ class Zoom
 
     def open(results)
         return if (results.nil? || results.empty?)
-
-        # All results should be from the same profile
-        profile = @config.get_profile(results[0].profile_name)
-        profile.go(@config.editor, results)
+        Zoom::Editor.new(@config.editor).open(results)
     end
 
     def repeat(shortcut = true)
@@ -33,39 +101,34 @@ class Zoom
         run(@cache.header, shortcut, true)
     end
 
-    def run(header, shortcut = true, repeat = false)
-        # Ensure header has no nil
-        ["args", "pattern", "profile_name"].each do |key|
-            header[key] ||= ""
-        end
-        header["paths"] ||= "."
-        header["pwd"] = Dir.pwd
-        header["translate"] ||= Array.new
-
-        profile_name = header["profile_name"]
-        if (profile_name.empty?)
-            profile_name = @config.current_profile_name
-            header["profile_name"] = profile_name
-        end
+    def run(h, shortcut = true, repeat = false)
+        # Don't change the header passed in
+        header = h.clone
 
-        if (!@config.has_profile?(profile_name))
-            raise Zoom::Error::ProfileDoesNotExist.new(profile_name)
-        end
+        # Ensure header is formatted properly and valid
+        header = ensure_valid_header(header) if (!repeat)
 
+        profile_name = header["profile_name"]
         profile = @config.get_profile(profile_name)
-        begin
-            # This will translate and/or append args such that the
-            # output will be something Zoom can process
-            header = profile.preprocess(header) if (!repeat)
 
+        begin
             # Clear cache
             @cache.clear
 
             # Store needed details
             @cache.header(header)
 
+            # Translate any needed flags
+            header["translated"] = profile.translate(
+                header["translate"]
+            ).strip
+
+            # This may append args such that the output will be
+            # something Zoom can process
+            header = profile.preprocess(header)
+
             # Execute profile
-            @cache.write(profile.exe(header), header["pattern"])
+            @cache.write(profile.exe(header), header["regex"])
 
             # Display results from cache
             @cache.shortcut(@config) if (shortcut)

data/lib/zoom/cache.rb

@@ -111,11 +111,6 @@ class Zoom::Cache
         return @header["paths"]
     end
 
-    def pattern
-        return nil if (@header.nil?)
-        return @header["pattern"]
-    end
-
     def profile_name
         return nil if (@header.nil?)
         return @header["profile_name"]
@@ -155,6 +150,11 @@ class Zoom::Cache
         end
     end
 
+    def regex
+        return nil if (@header.nil?)
+        return @header["regex"]
+    end
+
     def shortcut(config)
         return if (empty?)
 
@@ -184,7 +184,7 @@ class Zoom::Cache
                     config.hilight_tag("[#{result.tag}]"),
                     "#{config.hilight_lineno(result.lineno)}:",
                     result.match.gsub(
-                        /(#{pattern})/i,
+                        /(#{regex})/i,
                         config.hilight_match("\\1")
                     )
                 ].join(" ")
@@ -204,7 +204,7 @@ class Zoom::Cache
         end
     end
 
-    def write(str, pattern = nil)
+    def write(str, r = nil)
         return if (str.nil?)
 
         if (!str.valid_encoding?)
@@ -217,15 +217,16 @@ class Zoom::Cache
 
         File.open(@cache_file, "a") do |f|
             str.gsub(/\r/, "^M").split("\n").each do |line|
-                if (pattern && line.match(/^[^:]+:[0-9]+:.+$/))
+                if (r && line.match(/^[^:]+:[0-9]+:.+$/))
                     line.match(/^([^:]+:[0-9]+:)(.+)$/) do |m|
                         m[2].scan(
-                            /(.{0,128}#{pattern}.{0,128})/i
+                            /(.{0,128}#{r}.{0,128})/i
                         ) do |n|
                             f.write("#{m[1]}#{n[0]}\n")
                         end
                     end
                 else
+                    line.gsub!(/^(.{128}).*(.{128})$/, "\\1...\\2")
                     f.write("#{line}\n")
                 end
             end

data/lib/zoom/cache/result.rb

@@ -28,12 +28,12 @@ class Zoom::Cache::Result
                 @filename = "Binary file"
                 @contents = m[1]
             end
-        when /^([^:]+):(\d+)[:-](.*)$/
-            @contents.match(/^([^:]+):(\d+)[:-](.*)$/) do |m|
+        when /^([^:]+)[:-](\d+)[:-](.*)$/
+            @contents.match(/^([^:]+)[:-](\d+)[:-](.*)$/) do |m|
                 next if (m.nil?)
 
                 @grep_like = true
-                @filename = m[1]
+                @filename = m[1].gsub(/^\.\//, "")
                 @lineno = m[2]
                 @match = m[3]
             end

data/lib/zoom/config.rb

@@ -49,7 +49,7 @@ class Zoom::Config < JSONConfig
     end
 
     def default_config
-        default = Zoom::ProfileManager.default_profile
+        default = Zoom::ProfileManager.default_tool
         profiles = Zoom::ProfileManager.default_profiles
 
         clear
@@ -64,20 +64,29 @@ class Zoom::Config < JSONConfig
     end
 
     def editor(ed = nil)
-        if (ed)
-            e = ScoobyDoo.where_are_you(ed)
-            raise Zoom::Error::ExecutableNotFound.new(ed) if (e.nil?)
+        if (ed && !ed.empty?)
+            e = ed.split(" ")[0]
+            if (ScoobyDoo.where_are_you(e).nil?)
+                raise Zoom::Error::ExecutableNotFound.new(e)
+            end
             set("editor", ed)
         end
 
         e = get("editor")
         e = ENV["EDITOR"] if (e.nil? || e.empty?)
         e = "vim" if (e.nil? || e.empty?)
+
+        e, _, f = e.partition(" ")
         e = ScoobyDoo.where_are_you(e)
-        e = ScoobyDoo.where_are_you("vi") if (e.nil?)
+
+        if (e.nil?)
+            e = ScoobyDoo.where_are_you("vi")
+            f = ""
+        end
+
         raise Zoom::Error::ExecutableNotFound.new("vi") if (e.nil?)
 
-        return e
+        return "#{e} #{f}".strip
     end
 
     def has_profile?(name)

data/lib/zoom/editor.rb

@@ -42,7 +42,7 @@ class Zoom::Editor
     private :default
 
     def initialize(editor)
-        @editor = editor
+        @editor, _, @flags = editor.partition(" ")
     end
 
     def open(results)
@@ -61,11 +61,13 @@ class Zoom::Editor
             filename = result.filename
             lineno = result.lineno
             pwd = result.pwd
-            system("#{@editor} +#{lineno} '#{pwd}/#{filename}'")
+            system(
+                "#{@editor} #{@flags} +#{lineno} '#{pwd}/#{filename}'"
+            )
         else
             filename = result.contents
             pwd = result.pwd
-            system("#{@editor} '#{pwd}/#{filename}'")
+            system("#{@editor} #{@flags} '#{pwd}/#{filename}'")
         end
     end
     private :open_result
@@ -113,7 +115,9 @@ class Zoom::Editor
         zq.close
         zs.close
 
-        system("#{@editor} -S #{source} '#{files.join("' '")}'")
+        system(
+            "#{@editor} #{@flags} -S #{source} '#{files.join("' '")}'"
+        )
 
         FileUtils.rm_f(quickfix)
         FileUtils.rm_f(source)

data/lib/zoom/error.rb

@@ -7,3 +7,4 @@ require "zoom/error/invalid_tag"
 require "zoom/error/profile_class_unknown"
 require "zoom/error/profile_does_not_exist"
 require "zoom/error/profile_not_named"
+require "zoom/error/regex_not_provided"

data/lib/zoom/error/regex_not_provided.rb

@@ -0,0 +1,5 @@
+class Zoom::Error::RegexNotProvided < Zoom::Error
+    def initialize
+        super("A regex was not provided or hard-coded")
+    end
+end

data/lib/zoom/profile.rb

@@ -3,9 +3,11 @@ require "scoobydoo"
 require "shellwords"
 
 class Zoom::Profile < Hash
-    attr_reader :format_flags
-    attr_reader :pattern
-    attr_reader :taggable
+    attr_accessor :exts
+    attr_accessor :files
+    attr_accessor :format_flags
+    attr_accessor :regex
+    attr_accessor :taggable
 
     def after(a = nil)
         self["after"] = a.strip if (a)
@@ -35,30 +37,26 @@ class Zoom::Profile < Hash
 
     def exe(header)
         # Emulate grep
-        case operator.split("/")[-1]
-        when "find"
-            cmd = [
-                before,
-                operator,
-                header["paths"],
-                flags,
-                header["args"],
-                header["pattern"],
-                after
-            ].join(" ").strip
+        cmd = [
+            before,
+            tool,
+            @format_flags,
+            flags,
+            only_exts_and_files,
+            header["translated"],
+            header["args"],
+            "--",
+            header["regex"].shellescape,
+            header["paths"],
+            after
+        ].join(" ").strip
+
+        if (header.has_key?("debug") && header["debug"])
+            puts cmd
+            return ""
         else
-            cmd = [
-                before,
-                operator,
-                @format_flags,
-                flags,
-                header["args"],
-                header["pattern"].shellescape,
-                header["paths"],
-                after
-            ].join(" ").strip
+            return %x(#{cmd})
         end
-        return %x(#{cmd})
     end
 
     def flags(f = nil)
@@ -71,7 +69,7 @@ class Zoom::Profile < Hash
         begin
             return profile_by_name(json["class"]).new(
                 json["name"],
-                json["operator"].nil? ? "" : json["operator"],
+                json["tool"].nil? ? "" : json["tool"],
                 json["flags"].nil? ? "" : json["flags"],
                 json["before"].nil? ? "" : json["before"],
                 json["after"].nil? ? "" : json["after"]
@@ -83,8 +81,9 @@ class Zoom::Profile < Hash
         end
     end
 
-    def go(editor, results)
-        Zoom::Editor.new(editor).open(results)
+    def grep_like_format_flags(all = false)
+        @format_flags = "" # Set this to mirror basic grep
+        @taggable = false # Should results be tagged like grep
     end
 
     def hilight_after(str)
@@ -117,34 +116,41 @@ class Zoom::Profile < Hash
     end
     private :hilight_name
 
-    def hilight_operator(str)
+    def hilight_regex(str)
         return str if (!Zoom.hilight?)
-        return str.green
+        return str
     end
-    private :hilight_operator
+    private :hilight_regex
 
-    def hilight_pattern(str)
+    def hilight_tool(str)
         return str if (!Zoom.hilight?)
-        return str
+        return str.green
     end
-    private :hilight_pattern
+    private :hilight_tool
 
-    def initialize(n = nil, o = nil, f = nil, b = nil, a = nil)
+    def initialize(n = nil, t = nil, f = nil, b = nil, a = nil)
         a ||= ""
         b ||= ""
         f ||= ""
         n ||= camel_case_to_underscore(self.class.to_s)
-        o ||= "echo"
+        t ||= "echo"
 
         self["class"] = self.class.to_s
         after(a)
         before(b)
         flags(f)
         name(n)
-        operator(o)
+        tool(t)
+
+        @exts = Array.new # Set this to only search specified exts
+        @files = Array.new # Set this to noly search specified files
+        @regex = "" # Setting this will override user input
 
-        @pattern = "" # Setting this will override user input
+        # In case someone overrides grep_like_format_flags
+        @format_flags = ""
         @taggable = false
+
+        grep_like_format_flags
     end
 
     def name(n = nil)
@@ -153,56 +159,12 @@ class Zoom::Profile < Hash
         return self["name"]
     end
 
-    def operator(o = nil)
-        if (o)
-            o.strip!
-            op = ScoobyDoo.where_are_you(o)
-            raise Zoom::Error::ExecutableNotFound.new(o) if (op.nil?)
-            self["operator"] = o
-        end
-        return self["operator"]
+    def only_exts_and_files
+        # Do nothing
+        return ""
     end
 
     def preprocess(header)
-        # Use hard-coded pattern if defined
-        if (
-            @pattern &&
-            !@pattern.empty? &&
-            (header["pattern"] != @pattern)
-        )
-            header["args"] += " #{header["pattern"]}"
-            header["pattern"] = @pattern
-        end
-
-        case operator.split("/")[-1]
-        when /^ack(-grep)?$/, "ag", "grep", "pt"
-            paths = header["paths"].split(" ")
-            if (header["pattern"].empty? && !paths.empty?)
-                header["pattern"] = paths.delete_at(0)
-                header["paths"] = paths.join(" ").strip
-                header["paths"] = "." if (header["paths"].empty?)
-            end
-
-            # This isn't done here anymore as it'll break hilighting
-            # header["pattern"] = header["pattern"].shellescape
-        when "find"
-            # If additional args are passed, then assume pattern is
-            # actually an arg
-            if (header["args"] && !header["args"].empty?)
-                header["args"] += " #{header["pattern"]}"
-                header["pattern"] = ""
-            end
-
-            # If pattern was provided then assume it's an iname search
-            if (header["pattern"] && !header["pattern"].empty?)
-                header["pattern"] = "-iname \"#{header["pattern"]}\""
-            end
-        end
-
-        # Translate any needed flags
-        header["args"] += " #{translate(header["translate"])}"
-        header["args"].strip!
-
         return header
     end
 
@@ -216,7 +178,7 @@ class Zoom::Profile < Hash
         ObjectSpace.each_object(Class).select do |clas|
             if (clas < self)
                 begin
-                    clas.new(clas.to_s)
+                    clas.new
                     true
                 rescue Zoom::Error::ExecutableNotFound
                     false
@@ -232,17 +194,27 @@ class Zoom::Profile < Hash
         ret.push(hilight_name)
         ret.push("#{hilight_class}\n")
         ret.push(hilight_before(before)) if (!before.empty?)
-        ret.push(hilight_operator(operator)) if (!operator.empty?)
+        ret.push(hilight_tool(tool)) if (!tool.empty?)
         ret.push(hilight_flags(flags)) if (!flags.empty?)
-        if (@pattern.nil? || @pattern.empty?)
-            ret.push(hilight_pattern("PATTERN"))
+        if (@regex.nil? || @regex.empty?)
+            ret.push(hilight_regex("REGEX"))
         else
-            ret.push(hilight_pattern("\"#{@pattern}\""))
+            ret.push(hilight_regex("\"#{@regex}\""))
         end
         ret.push(hilight_after(after)) if (!after.empty?)
         return ret.join(" ").strip
     end
 
+    def tool(t = nil)
+        if (t)
+            t.strip!
+            tl = ScoobyDoo.where_are_you(t)
+            raise Zoom::Error::ExecutableNotFound.new(t) if (tl.nil?)
+            self["tool"] = t
+        end
+        return self["tool"]
+    end
+
     def translate(from)
         return ""
     end