ruby-zoom 3.5.0 → 4.0.0

data/lib/zoom/profile/ack.rb

@@ -1,36 +1,11 @@
-require "shellwords"
-require "zoom/profile"
-
 class Zoom::Profile::Ack < Zoom::Profile
-    def colors
-        'ACK_COLOR_LINENO=white ACK_COLOR_MATCH="black on_white"'
-    end
-
-    def exe(args, pattern)
-        if (pattern.nil? || pattern.empty?)
-            system(
-                "#{self.to_s} --pager \"#{@pager}\" #{args} " \
-                "#{self.append}"
-            )
-        else
-            system(
-                "#{self.to_s} --pager \"#{@pager}\" #{args} " \
-                "#{pattern.shellescape} #{self.append}"
-            )
-        end
-    end
-
-    def initialize(
-        operator = nil,
-        flags = "--smart-case",
-        envprepend = "",
-        append = ""
-    )
+    def initialize(n, o = "ack", f = "--smart-case", b = "", a = "")
         # Special case because of debian
-        operator = "ack"
-        operator = "ack-grep" if (ScoobyDoo.where_are_you("ack-grep"))
+        if ((o == "ack") && ScoobyDoo.where_are_you("ack-grep"))
+            o = "ack-grep"
+        end
 
-        super(operator, flags, envprepend, append)
+        super(n, o, f, b, a)
         @taggable = true
     end
 end

data/lib/zoom/profile/ag.rb

@@ -1,41 +1,6 @@
-require "shellwords"
-require "zoom/profile"
-
 class Zoom::Profile::Ag < Zoom::Profile
-    def colors
-        '--color-match "47;1;30" --color-line-number "0;37"'
-    end
-
-    def exe(args, pattern)
-        if (pattern.nil? || pattern.empty?)
-            system(
-                "#{self.to_s} --pager \"#{@pager}\" #{args} " \
-                "#{self.append}"
-            )
-        else
-            system(
-                "#{self.to_s} --pager \"#{@pager}\" #{args} " \
-                "#{pattern.shellescape} #{self.append}"
-            )
-        end
-    end
-
-    def initialize(
-        operator = nil,
-        flags = "",
-        envprepend = "",
-        append = ""
-    )
-        super("ag", flags, envprepend, append)
+    def initialize(n, o = "ag", f = "-S", b = "", a = "")
+        super(n, o, f, b, a)
         @taggable = true
     end
-
-    def to_s
-        [
-            self["prepend"],
-            self["operator"],
-            self.colors,
-            self["flags"]
-        ].join(" ").strip
-    end
 end

data/lib/zoom/profile/find.rb

@@ -1,29 +1,6 @@
-require "shellwords"
-require "zoom/profile"
-
 class Zoom::Profile::Find < Zoom::Profile
-    def exe(args, pattern)
-        if (pattern.nil? || pattern.empty?)
-            system(
-                "#{self.to_s} #{args} \"*\" #{self.append} | " \
-                "#{@pager}"
-            )
-        else
-            system(
-                "#{self.to_s} #{args} \"#{pattern}\" " \
-                "#{self.append} | #{@pager}"
-            )
-        end
-    end
-
-    def initialize(
-        operator = nil,
-        flags = ". -name",
-        envprepend = "",
-        append = ""
-    )
-        super("find", flags, envprepend, append)
-        @immutable = true
+    def initialize(n, o = "find", f = ". -name", b = "", a = "")
+        super(n, o, f, b, a)
         @taggable = true
     end
 end

data/lib/zoom/profile/grep.rb

@@ -1,48 +1,6 @@
-require "shellwords"
-require "zoom/profile"
-
 class Zoom::Profile::Grep < Zoom::Profile
-    def colors
-        [
-            'GREP_COLORS="',
-            "fn=1;32:",
-            "ln=0;37:",
-            "ms=47;1;30:",
-            "mc=47;1;30:",
-            "sl=:cx=:bn=:se=",
-            '"'
-        ].join.strip
-    end
-
-    def exe(args, pattern)
-        # Emulate ag/ack as much as possible
-        if (pattern.nil? || pattern.empty?)
-            system(
-                "#{self.to_s} #{args} #{self.append} | " \
-                "sed \"s|\\[K[:-]|\\[K\\n|\" | #{@pager}"
-            )
-        else
-            system(
-                "#{self.to_s} #{args} #{pattern.shellescape} " \
-                "#{self.append} | sed \"s|\\[K[:-]|\\[K\\n|\" | " \
-                "#{@pager}"
-            )
-        end
-    end
-
-    def initialize(
-        operator = nil,
-        flags = [
-            "--color=always",
-            "-EHIinR",
-            "--exclude-dir=.bzr",
-            "--exclude-dir=.git",
-            "--exclude-dir=.svn"
-        ].join(" ").strip,
-        envprepend = "",
-        append = "."
-    )
-        super("grep", flags, envprepend, append)
+    def initialize(n, o = "grep", f = "-Ii", b = "", a = ".")
+        super(n, o, f, b, a)
         @taggable = true
     end
 end

data/lib/zoom/profile/passwords.rb

@@ -1,72 +1,40 @@
-require "zoom/profile"
-require "zoom/profile/ag"
-require "zoom/profile/ack"
-require "zoom/profile/grep"
+require "zoom/profile_manager"
 
-class Zoom::Profile::Passwords < Zoom::Profile
-    def colors
-        return @profile.colors
+case Zoom::ProfileManager.default_profile
+when /^ack(-grep)?$/
+    class Zoom::Profile::Passwords < Zoom::Profile::Ack
     end
-
-    def exe(args, pattern)
-        @profile.exe(args, pattern)
+when "ag"
+    class Zoom::Profile::Passwords < Zoom::Profile::Ag
     end
-
-    def info
-        [
-            "Class   : #{self.class.to_s}",
-            "Prepend : #{@profile.prepend}",
-            "Operator: #{@profile.operator}",
-            "Flags   : #{@profile.flags}",
-            "Append  : #{@profile.append}"
-        ].join("\n").strip
+when "pt"
+    class Zoom::Profile::Passwords < Zoom::Profile::Pt
     end
+else
+    class Zoom::Profile::Passwords < Zoom::Profile::Grep
+    end
+end
 
-    def initialize(
-        operator = nil,
-        flags = "",
-        envprepend = "",
-        append = ""
-    )
-        @passwd_regex = "\"pass(word|wd)?[^:=,>]? *[:=,>]\""
+class Zoom::Profile::Passwords
+    def initialize(n, o = nil, f = "", b = "", a = "")
+        op = Zoom::ProfileManager.default_profile
 
-        if (ScoobyDoo.where_are_you("ag"))
-            @profile = Zoom::Profile::Ag.new(
-                nil,
-                "-uS",
-                "",
-                @passwd_regex
-            )
-        elsif (
-            ScoobyDoo.where_are_you("ack") ||
-            ScoobyDoo.where_are_you("ack-grep")
-        )
-            @profile = Zoom::Profile::Ack.new(
-                nil,
-                "--smart-case",
-                "",
-                @passwd_regex
+        case op
+        when /^ack(-grep)?$/
+            super(
+                n,
+                op,
+                "--smart-case --ignore-dir=test --ignore-dir=tests"
             )
+        when "ag"
+            super(n, op, "-Su --ignore=\"\/*test*\/\"")
+        when "pt"
+            super(n, op, "-SU --hidden --ignore=\"\/*test*\/\"")
         else
-            @profile = Zoom::Profile::Grep.new(
-                nil,
-                "--color=always -EHinR",
-                "",
-                @passwd_regex
-            )
+            super(n, op, "-ai --exclude-dir=test --exclude-dir=tests")
         end
 
-        super(
-            @profile.operator,
-            @profile.flags,
-            @profile.prepend,
-            @profile.append
-        )
-        @immutable = true
+        @pattern = "pass(word|wd)?[^:=,>]? *[:=,>]"
         @taggable = true
     end
-
-    def to_s
-        return @porfile.to_s
-    end
 end

data/lib/zoom/profile/pt.rb

@@ -1,30 +1,6 @@
-require "shellwords"
-require "zoom/profile"
-
 class Zoom::Profile::Pt < Zoom::Profile
-    def exe(args, pattern)
-        # Emulate ag/ack as much as possible
-        if (pattern.nil? || pattern.empty?)
-            system(
-                "#{self.to_s} #{args} #{self.append} | " \
-                "sed \"s|\\[K[:-]|\\[K\\n|\" | #{@pager}"
-            )
-        else
-            system(
-                "#{self.to_s} #{args} #{pattern.shellescape} " \
-                "#{self.append} | sed \"s|\\[K[:-]|\\[K\\n|\" | " \
-                "#{@pager}"
-            )
-        end
-    end
-
-    def initialize(
-        operator = nil,
-        flags = "--color -Se",
-        envprepend = "",
-        append = ""
-    )
-        super("pt", flags, envprepend, append)
+    def initialize(n, o = "pt", f = "-S", b = "", a = "")
+        super(n, o, f, b, a)
         @taggable = true
     end
 end

data/lib/zoom/profile_manager.rb

@@ -0,0 +1,49 @@
+require "pathname"
+require "scoobydoo"
+
+# Load custom profiles
+config_dir = Pathname.new("~/.config/zoom").expand_path
+if (config_dir.exist?)
+    Dir["#{config_dir}/*.rb"].each do |file|
+        require_relative file
+    end
+end
+
+class Zoom::ProfileManager
+    @@ranking = [
+        ["ag", "Zoom::Profile::Ag", "-Su"],
+        ["pt", "Zoom::Profile::Pt", "-SU --hidden"],
+        ["ack", "Zoom::Profile::Ack", ""],
+        ["ack-grep", "Zoom::Profile::Ack", ""],
+        ["grep", "Zoom::Profile::Grep", "-ai"],
+        ["find", "Zoom::Profile::Find", ""]
+    ]
+
+    def self.default_profile
+        @@ranking.each do |op, clas, all|
+            return op if (ScoobyDoo.where_are_you(op))
+        end
+        return nil # shouldn't happen
+    end
+
+    def self.default_profiles
+        profiles = Hash.new
+
+        @@ranking.each do |op, clas, all|
+            if (ScoobyDoo.where_are_you(op))
+                name = op.gsub("-grep", "")
+                obj = Zoom::Profile.profile_by_name(clas)
+                profiles[name] = obj.new(name)
+                if (!all.empty?)
+                    profiles["all"] ||= obj.new("all", name, all)
+                end
+            end
+        end
+
+        profiles["passwords"] = Zoom::Profile::Passwords.new(
+            "passwords"
+        )
+
+        return profiles
+    end
+end

data/lib/zoom/wish/add_wish.rb

@@ -0,0 +1,58 @@
+require "djinni"
+
+class AddWish < Djinni::Wish
+    def aliases
+        return ["add", "new"]
+    end
+
+    def description
+        return "Create a new profile"
+    end
+
+    def execute(args, djinni_env = {})
+        if (args.split(" ").length != 2)
+            usage
+            return
+        end
+
+        config = djinni_env["config"]
+        c, n = args.split(" ")
+
+        if (config.has_profile?(n))
+            puts "Profile already exists: #{n}"
+        elsif (!@classes.has_key?(c))
+            puts "Class does not exist: #{c}"
+        else
+            profiles = config.get_profiles
+            profiles[n] = Zoom::Profile.profile_by_name(c).new(n)
+            config.set_profiles(profiles)
+        end
+    end
+
+    def initialize
+        @classes = Hash.new
+        [Zoom::Profile].concat(Zoom::Profile.subclasses).each do |c|
+            @classes[c.to_s] = c.new(c.to_s).to_s.split("\n")[1].strip
+        end
+    end
+
+    def tab_complete(input, djinni_env = {})
+        return [{}, "", ""] if (input.include?(" "))
+
+        completions = @classes.select do |clas, desc|
+            clas.downcase.start_with?(input.downcase)
+        end
+
+        return [completions, input, " "]
+    end
+
+    def usage
+        puts "#{aliases.join(", ")} <class> <name>"
+        puts "    #{description}."
+        puts
+        puts "CLASSES"
+        @classes.each do |clas, desc|
+            puts "    #{clas}"
+        end
+    end
+end

data/lib/zoom/wish/color_wish.rb

@@ -0,0 +1,147 @@
+require "djinni"
+
+class ColorWish < Djinni::Wish
+    def aliases
+        return ["color"]
+    end
+
+    def description
+        return "Configure colors"
+    end
+
+    def execute(args, djinni_env = {})
+        f, found, c = args.rpartition(" ")
+        if (f.include?(" "))
+            usage
+            return
+        end
+
+        config = djinni_env["config"]
+
+        if (found.empty?)
+            f = c
+
+            case f
+            when "off"
+                config.hilight(false)
+            when "on"
+                config.hilight(true)
+            else
+                usage
+            end
+
+            return
+        end
+
+        case f
+        when "off", "on"
+            usage
+        else
+            c.split(".").each do |color|
+                if (!@colors.include?(color))
+                    puts "Invalid color: #{color}"
+                    return
+                end
+            end
+
+            config.send("color_#{f}", c)
+        end
+    end
+
+    def initialize
+        @colors = [
+            "black",
+            "blue",
+            "cyan",
+            "default",
+            "green",
+            "magenta",
+            "red",
+            "white",
+            "yellow",
+            "light_black",
+            "light_blue",
+            "light_cyan",
+            "light_green",
+            "light_magenta",
+            "light_red",
+            "light_white",
+            "light_yellow",
+            "on_black",
+            "on_blue",
+            "on_cyan",
+            "on_green",
+            "on_magenta",
+            "on_red",
+            "on_white",
+            "on_yellow",
+            "on_light_black",
+            "on_light_blue",
+            "on_light_cyan",
+            "on_light_green",
+            "on_light_magenta",
+            "on_light_red",
+            "on_light_white",
+            "on_light_yellow"
+        ]
+        @fields = {
+            "filename" => "Configure filename color (default: green)",
+            "lineno" =>
+                "Configure line number color (default: white)",
+            "match" =>
+                "Configure match color (default: black.on_white)",
+            "off" => "Turn off colorized output",
+            "on" => "Turn on colorized output (default)",
+            "tag" => "Configure tag color (default: red)"
+        }
+    end
+
+    def tab_complete(input, djinni_env = {})
+        f, found, c = input.rpartition(" ")
+
+        return [{}, "", ""] if (f.include?(" "))
+
+        if (found.empty?)
+            f = c
+
+            completions = @fields.select do |field, desc|
+                field.downcase.start_with?(f.downcase)
+            end
+
+            append = " "
+            append = "" if (f.start_with?("o"))
+            return [completions, f, append]
+        else
+            case f
+            when "off", "on"
+                return [{}, "", ""]
+            else
+                last = c.rpartition(".")[-1]
+
+                completions = Hash.new
+                @colors.select do |color|
+                    color.downcase.start_with?(last.downcase)
+                end.each do |color|
+                    completions[color] = ""
+                end
+
+                return [completions, last, ""]
+            end
+        end
+    end
+
+    def usage
+        puts "#{aliases.join(", ")} <field> [color]"
+        puts "    #{description}."
+        puts
+        puts "FIELDS"
+        @fields.each do |field, desc|
+            puts "    #{field}"
+        end
+        puts
+        puts "COLORS"
+        @colors.each do |color|
+            puts "    #{color}"
+        end
+    end
+end