ruby-zoom 3.5.0 → 4.0.0

data/lib/zoom/editor.rb

@@ -0,0 +1,121 @@
+require "fileutils"
+require "io/wait"
+
+class Zoom::Editor
+    def default(results)
+        # First result should never be nil, but better safe than sorry
+        first_result = results.delete_at(0)
+        open_result(first_result) if (first_result)
+
+        results.each do |result|
+            print "Open result #{result.tag} [y]/n/q/l?: "
+            answer = nil
+            while (answer.nil?)
+                begin
+                    system("stty raw -echo")
+                    if ($stdin.ready?)
+                        answer = $stdin.getc
+                    else
+                        sleep 0.1
+                    end
+                ensure
+                    system("stty -raw echo")
+                end
+            end
+            puts
+
+            case answer
+            when "n", "N"
+                # Do nothing
+            when "l", "L"
+                # Open this result then exit
+                open_result(result)
+                break
+            when "q", "Q", "\x03"
+                # Quit or ^C
+                break
+            else
+                open_result(result)
+            end
+        end
+    end
+    private :default
+
+    def initialize(editor)
+        @editor = editor
+    end
+
+    def open(results)
+        return if (results.nil? || results.empty?)
+
+        case @editor
+        when /vim?$/
+            vim(results)
+        else
+            default(results)
+        end
+    end
+
+    def open_result(result)
+        if (result.grep_like?)
+            filename = result.filename
+            lineno = result.lineno
+            pwd = result.pwd
+            system("#{@editor} +#{lineno} '#{pwd}/#{filename}'")
+        else
+            filename = result.contents
+            pwd = result.pwd
+            system("#{@editor} '#{pwd}/#{filename}'")
+        end
+    end
+    private :open_result
+
+    def vim(results)
+        quickfix = Pathname.new("~/.cache/zoom/quickfix").expand_path
+        source = Pathname.new("~/.cache/zoom/source").expand_path
+        FileUtils.mkdir_p(quickfix.dirname)
+
+        zq = File.open(quickfix, "w")
+        zs = File.open(source, "w")
+
+        vimscript = [
+            "augroup Zoom",
+            "  autocmd!",
+            "  autocmd FileType qf nnoremap <cr> :.cc<cr>:cclose<cr>",
+            "augroup END",
+            "",
+            "nnoremap <leader>z :copen<cr>",
+            "nnoremap zn :copen<cr>j:.cc<cr>:cclose<cr>",
+            "nnoremap zp :copen<cr>k:.cc<cr>:cclose<cr>",
+            ""
+        ].join("\n")
+        zs.write(vimscript)
+
+        files = Array.new
+        results.each do |result|
+            filename = result.filename if (result.grep_like?)
+            filename ||= result.contents
+            lineno = result.lineno
+            match = result.match
+            pwd = result.pwd
+
+            if (!files.include?("#{pwd}/#{filename}"))
+                files.push("#{pwd}/#{filename}")
+                zs.write("#{lineno}\nbnext\n") if (result.grep_like?)
+            end
+
+            if (result.grep_like?)
+                zq.write("#{pwd}/#{filename}|#{lineno}| #{match}\n")
+            end
+        end
+        zs.write("silent cfile #{quickfix}\n")
+
+        zq.close
+        zs.close
+
+        system("#{@editor} -S #{source} #{files.join(" ")}")
+
+        FileUtils.rm_f(quickfix)
+        FileUtils.rm_f(source)
+    end
+end

data/lib/zoom/error.rb

@@ -1,9 +1,9 @@
 class Zoom::Error < RuntimeError
 end
 
-require "zoom/error/executable_not_found_error"
-require "zoom/error/invalid_tag_error"
-require "zoom/error/profile_already_exists_error"
-require "zoom/error/profile_can_not_be_modified_error"
-require "zoom/error/profile_class_unknown_error"
-require "zoom/error/profile_does_not_exist_error"
+require "zoom/error/executable_not_found"
+require "zoom/error/invalid_color"
+require "zoom/error/invalid_tag"
+require "zoom/error/profile_class_unknown"
+require "zoom/error/profile_does_not_exist"
+require "zoom/error/profile_not_named"

data/lib/zoom/error/{executable_not_found_error.rb → executable_not_found.rb}

@@ -1,6 +1,4 @@
-require "zoom/error"
-
-class Zoom::Error::ExecutableNotFoundError < Zoom::Error
+class Zoom::Error::ExecutableNotFound < Zoom::Error
     def initialize(exe = nil)
         super("Executable not found: #{exe}") if (exe)
         super("Executable not found") if (exe.nil?)

data/lib/zoom/error/invalid_color.rb

@@ -0,0 +1,5 @@
+class Zoom::Error::InvalidColor < Zoom::Error
+    def initialize(color)
+        super("Invalid color: #{color}")
+    end
+end

data/lib/zoom/error/{invalid_tag_error.rb → invalid_tag.rb}

@@ -1,6 +1,4 @@
-require "zoom/error"
-
-class Zoom::Error::InvalidTagError < Zoom::Error
+class Zoom::Error::InvalidTag < Zoom::Error
     def initialize(tag = nil)
         super("Invalid tag: #{tag}") if (tag)
         super("Invalid tag") if (tag.nil?)

data/lib/zoom/error/{profile_class_unknown_error.rb → profile_class_unknown.rb}

@@ -1,6 +1,4 @@
-require "zoom/error"
-
-class Zoom::Error::ProfileClassUnknownError < Zoom::Error
+class Zoom::Error::ProfileClassUnknown < Zoom::Error
     def initialize(clas = nil)
         super("Profile class unknown: #{clas}") if (clas)
         super("Profile class unknown") if (clas.nil?)

data/lib/zoom/error/{profile_does_not_exist_error.rb → profile_does_not_exist.rb}

@@ -1,6 +1,4 @@
-require "zoom/error"
-
-class Zoom::Error::ProfileDoesNotExistError < Zoom::Error
+class Zoom::Error::ProfileDoesNotExist < Zoom::Error
     def initialize(profile = nil)
         super("Profile does not exist: #{profile}") if (profile)
         super("Profile does not exist") if (profile.nil?)

data/lib/zoom/error/profile_not_named.rb

@@ -0,0 +1,7 @@
+require "json"
+
+class Zoom::Error::ProfileNotNamed < Zoom::Error
+    def initialize(json)
+        super("Profile has no name:\n#{JSON.pretty_generate(json)}")
+    end
+end

data/lib/zoom/profile.rb

@@ -1,97 +1,171 @@
+require "hilighter"
 require "scoobydoo"
 require "shellwords"
-require "zoom/error/profile_class_unknown_error"
 
 class Zoom::Profile < Hash
-    attr_accessor :immutable
-    attr_accessor :taggable
+    attr_reader :pattern
+    attr_reader :taggable
 
-    @@cache_file = "~/.zoom_cache"
-
-    def append(append = nil)
-        self["append"] = append if (append)
-        return self["append"]
+    def after(a = nil)
+        self["after"] = a if (a)
+        return self["after"].strip
     end
 
-    def self.cache_file(cache_file)
-        @@cache_file = cache_file
-        @@cache_file ||= "~/.zoom_cache"
+    def before(b = nil)
+        self["before"] = b if (b)
+        return self["before"].strip
     end
 
-    def colors
-        # TODO color support
-        ""
+    def class_name
+        return self["class"]
     end
 
     def exe(args, pattern)
-        system("#{self.to_s} #{args} #{pattern} #{self.append}")
+        # Use hard-coded pattern if defined
+        pattern = @pattern if (@pattern && !@pattern.empty?)
+
+        # If not pattern and no after, then return nothing
+        if (pattern.nil? || pattern.empty?)
+            return "" if (after.nil? || after.empty? || after == ".")
+        end
+
+        # Emulate grep
+        case operator.split("/")[-1]
+        when "ack", "ack-grep"
+            str = [
+                before,
+                operator,
+                "-H --nobreak --nocolor --noheading -s",
+                flags
+            ].join(" ").strip
+            return %x(#{str} #{args} #{pattern.shellescape} #{after})
+        when "ag"
+            str = [
+                before,
+                operator,
+                "--filename --nobreak --nocolor --noheading --silent",
+                flags
+            ].join(" ").strip
+            return %x(#{str} #{args} #{pattern.shellescape} #{after})
+        when "find"
+            str = [before, operator, flags].join(" ").strip
+            return %x(#{str} #{args} \"#{pattern}\" #{after})
+        when "grep"
+            str = [
+                before,
+                operator,
+                "--color=never -EHnRs",
+                "--exclude-dir=.bzr",
+                "--exclude-dir=.git",
+                "--exclude-dir=.svn",
+                flags
+            ].join(" ").strip
+            return %x(#{str} #{args} #{pattern.shellescape} #{after})
+        when "pt"
+            str = [
+                before,
+                operator,
+                "-e --nocolor --nogroup",
+                flags
+            ].join(" ").strip
+            return %x(#{str} #{args} #{pattern.shellescape} #{after})
+        else
+            str = [before, operator, flags].join(" ").strip
+            return %x(#{str} #{args} #{pattern} #{after})
+        end
     end
 
-    def flags(flags = nil)
-        self["flags"] = flags if (flags)
-        return self["flags"]
+    def flags(f = nil)
+        self["flags"] = f if (f)
+        return self["flags"].strip
     end
 
     def self.from_json(json)
         begin
             return profile_by_name(json["class"]).new(
+                json["name"],
                 json["operator"].nil? ? "" : json["operator"],
                 json["flags"].nil? ? "" : json["flags"],
-                json["prepend"].nil? ? "" : json["prepend"],
-                json["append"].nil? ? "" : json["append"]
-            )
-        rescue NameError => e
-            raise Zoom::Error::ProfileClassUnknownError.new(
-                json["class"]
+                json["before"].nil? ? "" : json["before"],
+                json["after"].nil? ? "" : json["after"]
             )
+        rescue NoMethodError
+            raise Zoom::Error::ProfileNotNamed.new(json)
+        rescue NameError
+            raise Zoom::Error::ProfileClassUnknown.new(json["class"])
         end
     end
 
-    def info
-        [
-            "Class   : #{self.class.to_s}",
-            "Prepend : #{self["prepend"]}",
-            "Operator: #{self["operator"]}",
-            "Flags   : #{self["flags"]}",
-            "Append  : #{self["append"]}"
-        ].join("\n").strip
+    def go(editor, results)
+        Zoom::Editor.new(editor).open(results)
+    end
+
+    def hilight_after(str)
+        return str if (!Zoom.hilight?)
+        return str.yellow
+    end
+    private :hilight_after
+
+    def hilight_before(str)
+        return str if (!Zoom.hilight?)
+        return str.yellow
+    end
+    private :hilight_before
+
+    def hilight_class
+        return class_name if (!Zoom.hilight?)
+        return class_name.cyan
+    end
+    private :hilight_class
+
+    def hilight_flags(str)
+        return str if (!Zoom.hilight?)
+        return str.magenta
+    end
+    private :hilight_flags
+
+    def hilight_name
+        return name if (!Zoom.hilight?)
+        return name.white
+    end
+    private :hilight_name
+
+    def hilight_operator(str)
+        return str if (!Zoom.hilight?)
+        return str.green
+    end
+    private :hilight_operator
+
+    def hilight_pattern(str)
+        return str if (!Zoom.hilight?)
+        return str
     end
+    private :hilight_pattern
 
-    def initialize(
-        operator = "echo",
-        flags = "#",
-        envprepend = "",
-        append = ""
-    )
+    def initialize(n, o = "echo", f = "#", b = "", a = "")
         self["class"] = self.class.to_s
-        self.flags(flags)
-        self.prepend(envprepend)
-        self.append(append)
-        self.operator(operator)
+        after(a)
+        before(b)
+        flags(f.split(" ").uniq.join(" "))
+        name(n)
+        operator(o)
 
-        @immutable = false
-        @pager = "z --pager --cache-file #{@@cache_file}"
+        @pattern = "" # Setting this will override user input
         @taggable = false
     end
 
-    def operator(operator = nil)
-        if (operator)
-            op = ScoobyDoo.where_are_you(operator)
-            if (op)
-                self["operator"] = op
-            else
-                self["operator"] = ScoobyDoo.where_are_you("echo")
-                flags("")
-                prepend("")
-                append("#{operator} is not installed!")
-            end
-        end
-        return self["operator"]
+    def name(n = nil)
+        self["name"] = n if (n)
+        return self["name"].strip
     end
 
-    def prepend(envprepend = nil)
-        self["prepend"] = envprepend if (envprepend)
-        return self["prepend"]
+    def operator(o = nil)
+        if (o)
+            op = ScoobyDoo.where_are_you(o)
+            raise Zoom::Error::ExecutableNotFound.new(o) if (op.nil?)
+            self["operator"] = o
+        end
+        return self["operator"].strip
     end
 
     def self.profile_by_name(clas)
@@ -100,13 +174,35 @@ class Zoom::Profile < Hash
         end
     end
 
+    def self.subclasses
+        ObjectSpace.each_object(Class).select do |clas|
+            if (clas < self)
+                begin
+                    clas.new(clas.to_s)
+                    true
+                rescue Zoom::Error::ExecutableNotFound
+                    false
+                end
+            else
+                false
+            end
+        end
+    end
+
     def to_s
-        [
-            self.colors,
-            self["prepend"],
-            self["operator"],
-            self["flags"]
-        ].join(" ").strip
+        ret = Array.new
+        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_flags(flags)) if (!flags.empty?)
+        if (@pattern.nil? || @pattern.empty?)
+            ret.push(hilight_pattern("PATTERN"))
+        else
+            ret.push(hilight_pattern("\"#{@pattern}\""))
+        end
+        ret.push(hilight_after(after)) if (!after.empty?)
+        return ret.join(" ").strip
     end
 end