ruby-zoom 3.5.0 → 4.0.0

data/bin/zr

@@ -1,5 +1,8 @@
 #!/usr/bin/env ruby
 
+require "djinni"
+require "fileutils"
+require "hilighter"
 require "optparse"
 require "zoom"
 
@@ -8,7 +11,9 @@ class ZoomExit
     INVALID_OPTION = 1
     INVALID_ARGUMENT = 2
     MISSING_ARGUMENT = 3
-    EXCEPTION = 4
+    EXTRA_ARGUMENTS = 4
+    EXCEPTION = 5
+    AMBIGUOUS_ARGUMENT = 6
 end
 
 def parse(args)
@@ -16,76 +21,50 @@ def parse(args)
     options["action"] = "exec"
     options["cache_file"] = nil
     options["use"] = nil
+    options["verbose"] = false
 
-    info = "Do you like to search through code using ag, ack, or " \
-        "grep? Good! This tool is for you! Zoom adds some " \
-        "convenience to ag/ack/grep by allowing you to quickly " \
-        "open your search results in your editor of choice. When " \
-        "looking at large code-bases, it can be a pain to have to " \
-        "scroll to find the filename of each result. Zoom prints a " \
-        "tag number in front of each result that ag/ack/grep " \
-        "outputs. Then you can quickly open that tag number with " \
-        "Zoom to jump straight to the source. Zoom is even " \
-        "persistent across all your sessions! You can search in " \
-        "one terminal and jump to a tag in another terminal from " \
-        "any directory!"
+    info = [
+        "Do you like to search through code using ag, ack, grep, or",
+        "pt? Good! This tool is for you! Zoom adds some convenience",
+        "to ag/ack/grep/pt by allowing you to quickly open your",
+        "search results in your editor of choice. When looking at",
+        "large code-bases, it can be a pain to have to scroll to",
+        "find the filename of each result. Zoom prints a tag number",
+        "in front of each result that ag/ack/grep/pt outputs. Then",
+        "you can quickly open that tag number with Zoom to jump",
+        "straight to the source. Zoom is even persistent across all",
+        "your sessions! You can search in one terminal and jump to a",
+        "tag in another terminal from any directory!"
+    ].join(" ")
 
     parser = OptionParser.new do |opts|
+        opts.summary_width = 25
+
         opts.banner =
-            "Usage: #{File.basename($0)} [OPTIONS] <pattern>"
+            "Usage: #{File.basename($0)} [OPTIONS] [pattern]"
 
-        opts.on(
-            "-a",
-            "--add=NAME",
-            "Add a new profile with specified name"
-        ) do |name|
-            options["action"] = "add"
-            options["use"] = name
+        opts.on("", "DESCRIPTION")
+
+        info.scan(/\S.{0,76}\S(?=\s|$)|\S+/).each do |line|
+            opts.on("    #{line}")
         end
 
+        opts.on("", "OPTIONS")
+
         opts.on("-c", "--cache", "Show previous results") do
             options["action"] = "cache"
         end
 
         opts.on(
+            "-o",
             "--cache-file=FILE",
-            "Use the specified cache file"
+            "Use alternate cache"
         ) do |file|
             options["cache_file"] = file
         end
 
-        opts.on(
-            "-d",
-            "--delete=NAME",
-            "Delete profile with specified name"
-        ) do |name|
-            options["action"] = "delete"
-            options["use"] = name
-        end
-
-        opts.on(
-            "-e",
-            "--edit=NAME",
-            "Edit profile with specified name"
-        ) do |name|
-            options["action"] = "edit"
-            options["use"] = name
-        end
-
-        opts.on(
-            "--editor=EDITOR",
-            "Use the specified editor"
-        ) do |editor|
-            options["action"] = "editor"
-            options["use"] = editor
-        end
-
-        opts.on("--examples", "Show some examples") do
-            options["action"] = "examples"
-        end
-
-        opts.on("--find", "Use the zoom_find profile") do
-            options["use"] = "zoom_find"
+        opts.on("--find", "Use built-in find profile") do
+            options["use"] = "find"
         end
 
         opts.on(
@@ -106,65 +85,78 @@ def parse(args)
             options["action"] = "list_profiles"
         end
 
-        opts.on(
-            "--list-profile-names",
-            "List profile names for completion functions"
-        ) do
-            options["action"] = "list_profile_names"
+        opts.on("-r", "--repeat", "Repeat last Zoom command") do
+            options["action"] = "repeat"
         end
 
-        opts.on(
-            "--list-tags",
-            "List tags for completion functions"
-        ) do
-            options["action"] = "list_tags"
+        opts.on("-u", "--use=NAME", "Run specified profile") do |name|
+            options["use"] = name
         end
 
-        opts.on(
-            "--pager",
-            "Treat Zoom as a pager (internal use only)"
-        ) do
-            options["action"] = "pager"
+        opts.on("-w", "--which", "Display current profile") do
+            options["action"] = "which"
         end
 
-        opts.on("-r", "--repeat", "Repeat the last Zoom command") do
-            options["action"] = "repeat"
+        opts.on("", "CONFIGURE_OPTIONS")
+
+        opts.on(
+            "--configure",
+            "Open prompt to edit profiles"
+        ) do
+            options["action"] = "configure"
         end
 
-        opts.on("--rc", "Create default .zoomrc file") do
+        opts.on("--rc", "Create default config file") do
             options["action"] = "rc"
         end
 
+        opts.on("", "MISC_OPTIONS")
+
         opts.on(
-            "--rename=NAME",
-            "Rename the current profile"
-        ) do |name|
-            options["action"] = "rename"
-            options["rename"] = name
+            "--list-profile-names",
+            "List profile names for completion functions"
+        ) do
+            options["action"] = "list_profile_names"
         end
 
         opts.on(
-            "-s",
-            "--switch=NAME",
-            "Switch to profile with specified name"
-        ) do |name|
-            options["action"] = "switch"
-            options["use"] = name
+            "--list-tags",
+            "List tags for completion functions"
+        ) do
+            options["action"] = "list_tags"
+        end
+
+        opts.on("--nocolor", "Disable colorized output") do
+            Hilighter.disable
         end
 
         opts.on(
-            "-u",
-            "--use=NAME",
-            "Use specified profile one time only"
-        ) do |name|
-            options["use"] = name
+            "-v",
+            "--verbose",
+            "Show backtrace when error occurs"
+        ) do
+            options["verbose"] = true
         end
 
-        opts.on("-w", "--which", "Display the current profile") do
-            options["action"] = "which"
+        opts.on("--version", "Show version") do
+            options["action"] = "version"
         end
 
-        opts.on("", info.word_wrap(80))
+        opts.on(
+            "",
+            "EXAMPLES",
+            "    Execute default profile:",
+            "    $ z PATTERN",
+            "",
+            "    Execute specified profile:",
+            "    $ z -u grep PATTERN",
+            "",
+            "    Pass additional flags to default profile:",
+            "    $ z -- -A 3 PATTERN",
+            "",
+            "    Open tags:",
+            "    $ zg 10,20,30-40"
+        )
     end
 
     begin
@@ -181,13 +173,17 @@ def parse(args)
         puts e.message
         puts parser
         exit ZoomExit::MISSING_ARGUMENT
+    rescue OptionParser::AmbiguousOption => e
+        puts e.message
+        puts parser
+        exit ZoomExit::AMBIGUOUS_ARGUMENT
     end
 
     case File.basename($0)
     when "zc"
         options["action"] = "cache"
     when "zf"
-        options["use"] = "zoom_find"
+        options["use"] = "find"
     when "zg"
         options["action"] = "go"
         options["use"] = args[0]
@@ -196,7 +192,7 @@ def parse(args)
     when "zr"
         options["action"] = "repeat"
     when "z"
-        # do nothing, this is the normal usage
+        # Do nothing, this is the normal usage
     else
         options["use"] = File.basename($0)
     end
@@ -208,80 +204,126 @@ end
 
 options = parse(ARGV)
 
-zoom = Zoom.new(options["cache_file"])
 begin
+    if (options["action"] == "rc")
+        FileUtils.rm_f(Pathname.new("~/.zoomrc").expand_path)
+    end
+
+    zoom = Zoom.new(options["cache_file"], nil, !Hilighter.disable?)
+
     case options["action"]
-    when "add"
-        zoom.interactive_add_profile(options["use"])
     when "cache"
-        zoom.shortcut_cache
-    when "delete"
-        zoom.delete_profile(options["use"])
-    when "edit"
-        zoom.interactive_edit_profile(options["use"])
-    when "editor"
-        zoom.configure_editor(options["use"])
-    when "examples"
-        puts [
-            "EXAMPLES:",
-            "",
-            "Add a profile named test:",
-            "    $ z --add test",
-            "",
-            "Edit a profile named test:",
-            "    $ z --edit test",
-            "",
-            "Execute the current profile:",
-            "    $ z PATTERN",
-            "",
-            "Repeat the previous Zoom command:",
-            "    $ z --repeat",
-            "",
-            "Pass additional flags to the choosen operator:",
-            "    $ z -- -A 3 PATTERN",
-            "",
-            "Open a tag:",
-            "    $ z --go 10",
-            "",
-            "Open multiple tags:",
-            "    $ z --go 10,20,30-40"
-        ].join("\n")
+        zoom.cache.shortcut(zoom.config)
+    when "configure"
+        Zoom.hilight(false)
+        djinni = Djinni.new
+        djinni.load_wishes(
+            "#{File.dirname(__FILE__)}/../lib/zoom/wish"
+        )
+        djinni.prompt(
+            {
+                "cache" => zoom.cache,
+                "config" => zoom.config,
+                "prompt_color" => "white",
+                "zoom" => zoom
+            },
+            "zoom(#{zoom.config.current_profile_name})> ".white
+        )
     when "go"
-        zoom.loop_through_results(options["use"])
+        if (options["use"])
+            results = zoom.cache.get_results(options["use"])
+            zoom.open(results)
+        end
     when "list_profiles"
-        zoom.list_profiles
+        profiles = zoom.config.get_profiles
+        profiles.keys.sort do |a, b|
+            a.downcase <=> b.downcase
+        end.each do |name|
+            if (name == zoom.config.current_profile_name)
+                print "*".red if (Zoom.hilight?)
+                print "*" if (!Zoom.hilight?)
+            end
+
+            lines = profiles[name].to_s.scan(
+                /\S.{0,76}\S(?=\s|$)|\S+/
+            )
+            puts lines.delete_at(0)
+            lines.each do |line|
+                puts "    #{line}"
+            end
+        end
     when "list_profile_names"
-        zoom.list_profile_names
+        puts zoom.config.get_profile_names
     when "list_tags"
-        zoom.list_tags
-    when "pager"
-        zoom.pager
+        puts zoom.cache.available_tags
     when "repeat"
         zoom.repeat
     when "rc"
-        zoom.default
-    when "rename"
-        zoom.rename_profile(
-            options["rename"],
-            options["use"]
-        )
-    when "switch"
-        zoom.switch_profile(options["use"])
+        zoom.config.default_config
+        zoom.cache.clear
+    when "version"
+        __FILE__.match(/ruby-zoom-(\d+\.\d+\.\d+)/) do |m|
+            puts m[1]
+        end
     when "which"
-        zoom.show_current
+        name = zoom.config.current_profile_name
+        profile = zoom.config.get_profiles[name]
+
+        print "*".red if (Zoom.hilight?)
+        print "*" if (!Zoom.hilight?)
+
+        lines = profile.to_s.scan(/\S.{0,76}\S(?=\s|$)|\S+/)
+        puts lines.delete_at(0)
+        lines.each do |line|
+            puts "    #{line}"
+        end
     else
-        # Search and save results
-        zoom.exec_profile(
+        # Search and cache results
+        zoom.run(
             options["use"],
             options["subargs"],
             options["pattern"]
         )
     end
+rescue SystemExit
+    # Quit from djinni
+    # Exit gracefully
 rescue Zoom::Error => e
-    puts e.message
+    $stderr.puts e.message
+    if (options["verbose"])
+        e.backtrace.each do |line|
+            $stderr.puts line.yellow
+        end
+    end
     exit ZoomExit::EXCEPTION
+rescue Interrupt
+    # ^C
+    # Exit gracefully
+rescue Errno::EPIPE
+    # Do nothing. This can happen if piping to another program such as
+    # less. Usually if less is closed before Zoom is done with STDOUT.
 rescue Exception => e
-    puts e.message
+    $stderr.puts
+    $stderr.puts "Oops! Looks like an error has occured! Try " \
+        "resetting your configs with the"
+    $stderr.puts "following comand:"
+    $stderr.puts
+    $stderr.puts "    z --rc"
+    $stderr.puts
+    $stderr.puts "If the error persists, file a bug at:"
+    $stderr.puts
+    $stderr.puts "    https://gitlab.com/mjwhitta/zoom/issues"
+    $stderr.puts
+    $stderr.puts "Maybe the message below will help. If not, you " \
+        "can use the --verbose flag to get"
+    $stderr.puts "a backtrace."
+
+    $stderr.puts e.message.white.on_red
+    if (options["verbose"])
+        e.backtrace.each do |line|
+            $stderr.puts line.yellow
+        end
+    end
     exit ZoomExit::EXCEPTION
 end
 exit ZoomExit::GOOD

data/lib/zoom.rb

@@ -1,637 +1,81 @@
-require "io/wait"
-require "json"
 require "pathname"
-require "string"
 
 class Zoom
-    def add_profile(
-        name,
-        clas,
-        operator = nil,
-        flags = nil,
-        envprepend = nil,
-        append = nil
-    )
-        if (@profiles.has_key?(name))
-            raise Zoom::Error::ProfileAlreadyExistsError.new(name)
-        end
-
-        default_class = nil
-        begin
-            default_class = Zoom::Profile.profile_by_name(clas).new
-        rescue NameError => e
-            raise Zoom::Error::ProfileClassUnknownError.new(clas)
-        end
+    attr_reader :cache
+    attr_reader :config
 
-        edit_profile(
-            name,
-            default_class,
-            operator,
-            flags,
-            envprepend,
-            append
-        )
+    def self.hilight(hilight = true)
+        @@hilight = hilight
     end
 
-    def clear_cache
-        @cache_file.delete if (@cache_file.exist?)
+    def self.hilight?
+        @@hilight ||= false
+        return @@hilight
     end
 
-    def configure_editor(editor)
-        e = ScoobyDoo.where_are_you(editor)
-        if (e.nil?)
-            raise Zoom::Error::ExecutableNotFoundError.new(editor)
-        end
+    def initialize(cache = nil, rc = nil, hilight = false)
+        @@hilight = hilight
+        @cache = Zoom::Cache.new(cache)
+        @config = Zoom::Config.new(rc)
 
-        @rc["editor"] = e
-        write_zoomrc
+        # Prioritize false, so only reassign if true
+        @@hilight = @config.hilight if (hilight)
     end
 
-    def default
-        default_zoominfo
-        default_zoomrc
-    end
-
-    def default_zoominfo
-        info = Hash.new
-        info["profile"] = "default"
-
-        # Reset last command to be empty
-        info["last_command"] = Hash.new
+    def open(results)
+        return if (results.nil? || results.empty?)
 
-        File.open(@info_file, "w") do |file|
-            file.write(JSON.pretty_generate(info))
-        end
+        # All results should be from the same profile
+        profile = @config.get_profile(results[0].profile_name)
+        profile.go(@config.editor, results)
     end
 
-    def default_zoomrc
-        rc = Hash.new
-        profiles = Hash.new
-
-        all = nil
-        ag = nil
-        pt = nil
-        ack = nil
-
-        # Default ag profiles
-        if (ScoobyDoo.where_are_you("ag"))
-            ag = Zoom::Profile::Ag.new
-            all = Zoom::Profile::Ag.new(nil, "-u")
-        end
-
-        # Default pt profiles
-        if (ScoobyDoo.where_are_you("pt"))
-            pt = Zoom::Profile::Pt.new
-            all ||= Zoom::Profile::Pt.new(nil, "--color -SeU")
-        end
+    def repeat
+        return if (@cache.empty?)
 
-        # Default ack profile
-        if (
-            ScoobyDoo.where_are_you("ack") ||
-            ScoobyDoo.where_are_you("ack-grep")
+        run(
+            @cache.profile_name,
+            @cache.args,
+            @cache.pattern
         )
-            ack = Zoom::Profile::Ack.new
-        end
-
-        # Default grep profile (emulate ag/ack as much as possible)
-        grep = Zoom::Profile::Grep.new
-        all ||= Zoom::Profile::Grep.new(nil, "--color=always -EHinR")
-
-        # Create default profile
-        if (ag)
-            default = ag
-        elsif (pt)
-            default = pt
-        elsif (ack)
-            default = ack
-        else
-            default = grep
-        end
-
-        # Create find profile
-        find = Zoom::Profile::Find.new
-
-        # Put profiles into rc
-        profiles["ack"] = ack if (ack)
-        profiles["ag"] = ag if (ag)
-        profiles["all"] = all if (all)
-        profiles["default"] = default
-        profiles["grep"] = grep
-        profiles["passwords"] = Zoom::Profile::Passwords.new
-        profiles["pt"] = pt if (pt)
-        profiles["zoom_find"] = find
-        rc["profiles"] = profiles
-
-        # Default editor (use $EDITOR)
-        rc["editor"] = ""
-
-        File.open(@rc_file, "w") do |file|
-            file.write(JSON.pretty_generate(rc))
-        end
-    end
-
-    def delete_profile(name)
-        if (!@profiles.has_key?(name))
-            raise Zoom::Error::ProfileDoesNotExistError.new(name)
-        end
-
-        if ((name == "default") || @profiles[name].immutable)
-            raise Zoom::Error::ProfileCanNotBeModifiedError.new(name)
-        end
-
-        @profiles.delete(name)
-        write_zoomrc
-
-        if (name == @info["profile"])
-            @info["profile"] = "default"
-            write_zoominfo
-        end
     end
 
-    def edit_profile(
-        name,
-        profile = nil,
-        operator = nil,
-        flags = nil,
-        envprepend = nil,
-        append = nil
-    )
-        profile = @profiles[name] if (profile.nil?)
+    def run(prof_name, args, pattern)
+        prof_name = @config.current_profile_name if (prof_name.nil?)
 
-        if (profile.nil?)
-            raise Zoom::Error::ProfileDoesNotExistsError.new(name)
+        if (!@config.has_profile?(prof_name))
+            raise Zoom::Error::ProfileDoesNotExist.new(prof_name)
         end
 
-        if (profile.immutable)
-            raise Zoom::Error::ProfileCanNotBeModifiedError.new(name)
-        end
-
-        profile.operator(operator) if (operator)
-        profile.flags(flags) if (flags)
-        profile.prepend(envprepend) if (envprepend)
-        profile.append(append) if (append)
-
-        @profiles[name] = profile
-        write_zoomrc
-    end
-
-    def exec_profile(name, args, pattern)
-        name = @info["profile"] if (name.nil?)
-
-        if (!@profiles.has_key?(name))
-            raise Zoom::Error::ProfileDoesNotExistError.new(name)
-        end
-
-        @info["last_command"] = {
-            "profile" => name,
-            "subargs" => args.nil? ? "": args,
-            "pattern" => pattern.nil? ? "" : pattern
-        }
-        write_zoominfo
-
-        profile = @profiles[name]
+        profile = @config.get_profile(prof_name)
         begin
-            clear_cache if (profile.taggable)
-            profile.exe(args, pattern)
-            shortcut_cache(profile) if (profile.taggable)
-        rescue Interrupt
-            # ^C
-        end
-    end
-
-    def get_location_of_result(result)
-        count = 0
-        File.open(@shortcut_file) do |file|
-            file.each do |line|
-                count += 1
-                if (count == result)
-                    return line
-                end
-            end
-        end
-        return nil
-    end
-    private :get_location_of_result
-
-    def get_new_value(val, default)
-        return default if (val.nil? || val.empty?)
-        return "" if (val.downcase == "empty")
-        return "" if (val.downcase == "\"empty\"")
-        return val
-    end
-    private :get_new_value
-
-    def initialize(cache_file = nil)
-        cache_file ||= "~/.zoom_cache"
-        Zoom::Profile.cache_file(cache_file)
-        @cache_file = Pathname.new(cache_file).expand_path
-        @info_file = Pathname.new("~/.zoominfo").expand_path
-        @rc_file = Pathname.new("~/.zoomrc").expand_path
-        @shortcut_file = Pathname.new("~/.zoom_shortcuts").expand_path
-
-        # Load custom profiles
-        custom_profs = Pathname.new("~/.zoom_profiles.rb").expand_path
-        require_relative custom_profs if (custom_profs.exist?)
-
-        read_zoomrc
-        read_zoominfo
-
-        # Setup editor
-        @editor = @rc["editor"]
-        @editor = ENV["EDITOR"] if (@editor.nil? || @editor.empty?)
-        @editor = "vim" if (@editor.nil? || @editor.empty?)
-        @editor = ScoobyDoo.where_are_you(@editor)
-        @editor = ScoobyDoo.where_are_you("vi") if (@editor.nil?)
-
-    end
-
-    def interactive_add_profile(name)
-        if (@profiles.has_key?(name))
-            raise Zoom::Error::ProfileAlreadyExistsError.new(name)
-        end
-
-        default_op = "grep"
-        if (ScoobyDoo.where_are_you("ag"))
-            default_op = "ag"
-        elsif (ScoobyDoo.where_are_you("pt"))
-            default_op = "pt"
-        elsif (ScoobyDoo.where_are_you("ack"))
-            default_op = "ack"
-        elsif (ScoobyDoo.where_are_you("ack-grep"))
-            default_op = "ack-grep"
-        end
-
-        ack_class = Zoom::Profile::Ack.to_s
-        ag_class = Zoom::Profile::Ag.to_s
-        grep_class = Zoom::Profile::Grep.to_s
-        pt_class = Zoom::Profile::Pt.to_s
-
-        case default_op
-        when "ack", "ack-grep"
-            puts "Enter class (default #{ack_class}):"
-        when "ag"
-            puts "Enter class (default #{ag_class}):"
-        when "grep"
-            puts "Enter class (default #{grep_class}):"
-        when "pt"
-            puts "Enter class (default #{pt_class}):"
-        end
+            @cache.clear
 
-        clas = gets.chomp
-        puts if (clas && !clas.empty?)
-
-        case default_op
-        when "ack", "ack-grep"
-            clas = ack_class if (clas.nil? || clas.empty?)
-        when "ag"
-            clas = ag_class if (clas.nil? || clas.empty?)
-        when "grep"
-            clas = grep_class if (clas.nil? || clas.empty?)
-        when "pt"
-            clas = pt_class if (clas.nil? || clas.empty?)
-        end
-
-        add_profile(name, clas)
-        interactive_edit_profile(name)
-    end
-
-    def interactive_edit_profile(name, profile = nil)
-        profile = @profiles[name] if (profile.nil?)
-
-        if (profile.nil?)
-            raise Zoom::Error::ProfileDoesNotExistError.new(name)
-        end
-
-        if (profile.immutable)
-            raise Zoom::Error::ProfileCanNotBeModifiedError.new(name)
-        end
-
-        # Get new operator
-        puts "Enter operator (default #{profile.operator}):"
-
-        op = ScoobyDoo.where_are_you(gets.chomp)
-        puts if (op && !op.empty?)
-        op = profile.operator if (op.nil? || op.empty?)
-
-        # Get new flags
-        puts "For empty string put \"empty\""
-        puts "Enter flags (default \"#{profile.flags}\"):"
-
-        flags = gets.chomp
-        puts if (flags && !flags.empty?)
-        flags = get_new_value(flags, profile.flags)
-
-        # Get new prepend
-        puts "For empty string put \"empty\""
-        puts "Enter prepend (default \"#{profile.prepend}\"):"
-
-        envprepend = gets.chomp
-        puts if (envprepend && !envprepend.empty?)
-        envprepend = get_new_value(envprepend, profile.prepend)
-
-        # Get new append
-        puts "For empty string put \"empty\""
-        puts "Enter append (default \"#{profile.append}\"):"
-
-        append = gets.chomp
-        puts if (append && !append.empty?)
-        append = get_new_value(append, profile.append)
-
-        edit_profile(name, profile, op, flags, envprepend, append)
-    end
-
-    def list_profile_names
-        @profiles.keys.sort.each do |name|
-            puts name
-        end
-    end
-
-    def list_profiles
-        @profiles.keys.sort.each do |name|
-            if (name == @info["profile"])
-                puts "### #{name} ###".green
-            else
-                puts "### #{name} ###"
-            end
-            puts @profiles[name].info
-            puts
-        end
-    end
-
-    def list_tags
-        return if (!@cache_file.exist?)
-
-        # Open shortcut file for writing
-        shct = File.open(@shortcut_file, "r")
-
-        # Read in cache
-        File.open(@cache_file) do |cache|
-            count = 1
-
-            cache.each do |line|
-                line.chomp!
-                plain = remove_colors(line)
-                if (line.start_with?("ZOOM_EXE_DIR="))
-                    # Ignore this line
-                elsif ((line == "-") || (line == "--") || line.empty?)
-                    # Ignore dividers when searching with context and
-                    # empty lines
-                elsif (plain.scan(/^[0-9]+[:-]/).empty?)
-                    if (!plain.scan(/^\.\//).empty?)
-                        # Operator was probably find
-                        puts count
-                        count += 1
-                    end
-                else
-                    puts count
-                    count += 1
-                end
-            end
-        end
-    end
-
-    def loop_through_results(results)
-        tags = parse_tags(results)
-        return if (tags.empty?)
-
-        tag = tags.delete_at(0)
-        open_editor_to_result(tag)
-
-        tags.each do |tag|
-            print "Do you want to open 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_editor_to_result(tag)
-                return
-            when "q", "Q", "\x03"
-                # Quit or ^C
-                return
+            # Store needed details
+            if (pattern && profile.pattern.empty?)
+                @cache.args(args)
+                @cache.pattern(pattern)
             else
-                open_editor_to_result(tag)
+                @cache.args("")
+                @cache.pattern(profile.pattern)
             end
-        end
-    end
+            @cache.profile_name(prof_name)
+            @cache.pwd(Dir.pwd)
 
-    def open_editor_to_result(result)
-        loc = get_location_of_result(result.to_i)
-        if (loc)
-            system("#{@editor} #{loc}")
-        else
-            puts "Invalid tag \"#{result}\"!"
-        end
-    end
-    private :open_editor_to_result
-
-    def pager
-        File.open(@cache_file, "w") do |f|
-            f.write("ZOOM_EXE_DIR=#{Dir.pwd}\n")
-            begin
-                $stdin.each_line do |line|
-                    f.write(line)
-                end
-            rescue Interrupt
-                # ^C
-            end
-        end
-    end
-
-    def parse_tags(results)
-        tags = Array.new
-        if (results.nil? || results.empty?)
-            raise Zoom::Error::InvalidTagError.new
-        end
-
-        results.split(",").each do |num|
-            if (!num.scan(/^[0-9]+$/).empty?)
-                tags.push(num.to_i)
-            elsif (!num.scan(/^[0-9]+-[0-9]+$/).empty?)
-                range = num.split("-")
-                (range[0].to_i..range[1].to_i).each do |i|
-                    tags.push(i)
-                end
-            else
-                raise Zoom::Error::InvalidTagError.new(num)
-            end
-        end
-        return tags
-    end
-    private :parse_tags
-
-    def read_zoominfo
-        if (!@info_file.exist? && !@info_file.symlink?)
-            default_zoominfo
-        end
-
-        @info = JSON.parse(File.read(@info_file))
-    end
-    private :read_zoominfo
-
-    def read_zoomrc
-        if (!@rc_file.exist? && !@rc_file.symlink?)
-            default_zoomrc
-        end
-
-        @rc = JSON.parse(File.read(@rc_file))
-        @profiles = Hash.new
-        @rc["profiles"].each do |name, prof|
-            @profiles[name] = Zoom::Profile.from_json(prof)
-        end
-        @rc["profiles"] = @profiles
-    end
-    private :read_zoomrc
+            # Execute profile
+            @cache.write(profile.exe(args, pattern))
 
-    def rename_profile(rename, name = nil)
-        name = @info["profile"] if (name.nil?)
-
-        if ((name == "default") || (name == "zoom_find"))
-            raise Zoom::Error::ProfileCanNotBeModifiedError.new(name)
-        end
-
-        if (!@profiles.has_key?(name))
-            raise Zoom::Error::ProfileDoesNotExistError.new(name)
-        end
-
-        if (@profiles.has_key?(rename))
-            raise Zoom::Error::ProfileAlreadyExistsError.new(rename)
-        end
-
-        @profiles[rename] = @profiles[name]
-        @profiles.delete(name)
-        write_zoomrc
-
-        if (name == @info["profile"])
-            @info["profile"] = rename
-            write_zoominfo
-        end
-    end
-
-    def repeat
-        return if (@info["last_command"].empty?)
-
-        exec_profile(
-            @info["last_command"]["profile"],
-            @info["last_command"]["subargs"],
-            @info["last_command"]["pattern"]
-        )
-    end
-
-    def remove_colors(str)
-        str.unpack("C*").pack("U*").gsub(/\e\[([0-9;]*m|K)/, "")
-    end
-    private :remove_colors
-
-    def shortcut_cache(profile = nil)
-        return if (!@cache_file.exist?)
-        return if (@info["last_command"].empty?)
-
-        if (profile.nil?)
-            profile = @profiles[@info["last_command"]["profile"]]
-        end
-
-        # Open shortcut file for writing
-        shct = File.open(@shortcut_file, "w")
-
-        # Read in cache
-        File.open(@cache_file) do |cache|
-            start_dir = ""
-            file = nil
-            filename = ""
-            first_time = true
-            count = 1
-
-            cache.each do |line|
-                line.chomp!
-                plain = remove_colors(line)
-                if (line.start_with?("ZOOM_EXE_DIR="))
-                    # Get directory where search was ran
-                    start_dir = line.gsub("ZOOM_EXE_DIR=", "")
-                elsif ((line == "-") || (line == "--") || line.empty?)
-                    # Ignore dividers when searching with context and
-                    # empty lines
-                elsif (plain.scan(/^[0-9]+[:-]/).empty?)
-                    operator = profile.operator.split("/").last
-                    if (operator != "find")
-                        if (file != line)
-                            # Filename
-                            file = line
-                            filename = remove_colors(file)
-
-                            puts if (!first_time)
-                            first_time = false
-
-                            puts "\e[0m#{file}"
-                        end
-                    else
-                        # Operator was find
-                        puts "\e[1;31m[#{count}]\e[0m #{line}"
-                        shct.write("'#{start_dir}/#{line}'\n")
-                        count += 1
-                    end
-                elsif (file)
-                    # Match
-                    sanitized = line.unpack("C*").pack("U*")
-                        .gsub(/[\u0080-\u00ff]+/, "\1".dump[1..-2])
-                    puts "\e[1;31m[#{count}]\e[0m #{sanitized}"
-
-                    lineno = remove_colors(line).split(/[:-]/)[0]
-                    shct.write(
-                        "+#{lineno} '#{start_dir}/#{filename}'\n"
-                    )
-
-                    count += 1
-                end
-            end
-        end
-    end
-
-    def show_current
-        puts "### #{@info["profile"]} ###".green
-        puts @profiles[@info["profile"]].info
-    end
-
-    def switch_profile(name)
-        if (!@profiles.has_key?(name))
-            raise Zoom::Error::ProfileDoesNotExistError.new(name)
-        end
-
-        @info["profile"] = name
-        write_zoominfo
-    end
-
-    def write_zoominfo
-        File.open(@info_file, "w") do |file|
-            file.write(JSON.pretty_generate(@info))
-        end
-    end
-    private :write_zoominfo
-
-    def write_zoomrc
-        @rc["profiles"] = @profiles
-        File.open(@rc_file, "w") do |file|
-            file.write(JSON.pretty_generate(@rc))
+            # Display results from cache
+            @cache.shortcut(@config)
+        rescue Interrupt
+            # ^C
         end
     end
-    private :write_zoomrc
 end
 
+require "zoom/cache"
+require "zoom/config"
+require "zoom/editor"
 require "zoom/error"
 require "zoom/profile"
+require "zoom/profile_manager"