booker 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93b6a3c6bf829119ae61f5f00420929df7826d9755fe455d2e96512a0750ab49
-  data.tar.gz: 0a66a91c861b95e091441dfb5006033e8181a67aae1bed35e7e909efe66f5d6f
+  metadata.gz: fc8148125669f4128e710ef78210347f90caf80f5753ffbacf48f0b78af6f851
+  data.tar.gz: 1deea2d2a8f289eaefb670c77cfe5a2a8696c2dcaafcbb96b990eda0e8269384
 SHA512:
-  metadata.gz: 94db993a684f9b7e5cc06f308975054c3af63224a9b26082253ec3e0c227522aeb9ad948ab0c800b901ce8d32629fa98e8596daf635cdfc0935bf8329b1f04ba
-  data.tar.gz: cab7a43c4b8a251761b91194657e3526e9a2f806041f72a55c52ea545557814e4117b13cb52bc2ab0a1a059e68821d989b470c9a7e1e4954c54bbd2282cd9940
+  metadata.gz: b769f210cd3153dafe3240119044e742765bc260afcbf963daec319c135975799376446198fb9cecc68a3ad277ffb43fe33bc3529ad8af62a79cf6403ecfc577
+  data.tar.gz: b2c40993f4f25aac98a5a2549eba4f933e31d504c1f6f85245b075eda2ba2072f26154a97fded5dc2e429738f127fc90617d7d6f52b0ba35b1e17c5a333f6443

data/lib/booker.rb

@@ -1,16 +1,16 @@
 # parse booker's command line args
-require 'yaml'
-require 'find'
-require 'json'
-require 'shellwords'
-require_relative 'bookmarks'
-require_relative 'config'
-require_relative 'consts'
-
+require "yaml"
+require "find"
+require "json"
+require "shellwords"
+require "fileutils"
+require_relative "bookmarks"
+require_relative "config"
+require_relative "consts"
 
 # get booker opening command
 class Booker
-  @version = "1.1.0"
+  @version = "1.2.0"
   @@version = @version
 
   class << self
@@ -18,27 +18,45 @@ class Booker
   end
 
   include Browser
+
   def initialize(args)
     parse args
   end
 
   def parse(args)
-    # no args given, show help
-    helper if args.none?
+    # no args given, show interactive bookmark selector
+    show_bookmarks if args.none?
 
     # if arg starts with hyphen, parse option
-    parse_opt args if /^-.*/.match(args.first)
+    parse_opt args if /^-.*/.match?(args.first)
 
-    # interpret command
-    browsearg = args.first
+    # separate bookmark IDs from other args
+    bookmark_ids = []
+    other_args = []
 
-    if browsearg.match(/^[0-9]/) # bookmark
-      open_bookmark args
-    elsif domain.match(browsearg) # website
-      puts 'opening website: ' + browsearg
-      openweb(prep(browsearg))
-    else
-      open_search(args.join(' ').strip)
+    args.each do |arg|
+      if /^[0-9_]+$/.match?(arg)  # bookmark ID (digits or underscore)
+        bookmark_ids << arg
+      else
+        other_args << arg
+      end
+    end
+
+    # open all bookmarks first
+    unless bookmark_ids.empty?
+      open_bookmark bookmark_ids
+    end
+
+    # then handle remaining args
+    unless other_args.empty?
+      if other_args.length == 1 && domain.match(other_args.first)
+        # single website URL
+        puts "opening website: " + other_args.first
+        openweb(prep(other_args.first))
+      else
+        # search for the rest
+        open_search(other_args.join(" ").strip)
+      end
     end
   end
 
@@ -56,7 +74,16 @@ class Booker
   end
 
   def openweb(url)
-    system(browse + wrap(url))
+    # Pass URL directly to browser without invoking shell
+    # This avoids issues with special characters like parentheses
+    browser_cmd = browse.strip
+
+    # Redirect stdout/stderr to suppress GTK warnings
+    success = system(browser_cmd, url, out: "/dev/null", err: "/dev/null")
+
+    unless success
+      puts "Warning: ".yel + "Failed to open URL (exit code: #{$?.exitstatus})"
+    end
   end
 
   # an array of ints, as bookmark ids
@@ -64,64 +91,114 @@ class Booker
     id = bm.shift
     url = Bookmarks.new.bookmark_url(id)
     pexit "Failure:".red + " bookmark #{id} not found", 1 if url.nil?
-    puts 'opening bookmark ' + url + '...'
-    openweb(wrap(url))
+    puts "opening bookmark " + url + "..."
+    openweb(url)  # No wrap() needed - system() handles it
     open_bookmark bm unless bm.empty?
   end
 
   def open_search(term)
-    puts 'searching ' + term + '...'
+    puts "searching " + term + "..."
     search = BConfig.new.searcher
-    term = term.gsub(' ', '+')
-    openweb(search + Shellwords.escape(term))
+    term = term.tr(" ", "+")
+    openweb(search + term)  # No shell escape needed - it's a URL
+  end
+
+  def show_bookmarks
+    puts "Bookmarks:".grn + " (usage: booker <id> or booker <search>)"
+    puts ""
+
+    bm = Bookmarks.new("")  # Get all bookmarks
+    allurls = bm.instance_variable_get(:@allurls)
+
+    if allurls.empty?
+      puts "No bookmarks found.".red
+      puts "Run: ".yel + "booker --install bookmarks".cyan
+      exit 0
+    end
+
+    # Calculate responsive column widths
+    term_width = `tput cols`.to_i
+    term_width = 100 if term_width == 0  # fallback
+
+    id_width = 10
+    remaining = term_width - id_width - 3  # 3 spaces between columns
+
+    folder_width = [remaining * 0.20, 15].max.to_i
+    title_width = [remaining * 0.30, 20].max.to_i
+    url_width = [remaining * 0.50, 30].max.to_i
+
+    # Display bookmarks in a readable format
+    allurls.each do |bookmark|
+      id_str = bookmark.id.to_s.window(id_width).grn
+
+      # Clean up folder display
+      folder = bookmark.folder.gsub(/^\|/, "")  # Remove leading |
+      folder = (folder == "/") ? "[root]" : folder.chomp("/")  # Show [root] for top-level
+      folder_str = folder.window(folder_width).blu
+
+      title_str = bookmark.title.window(title_width).yel
+      url_str = bookmark.url.window(url_width)
+
+      puts "#{id_str} #{folder_str} #{title_str} #{url_str}"
+    end
+
+    puts ""
+    puts "Found #{allurls.length} bookmarks".grn
+    puts ""
+    puts "Examples:".yel
+    puts "  #{"booker #{allurls.first.id}".ljust(20).cyan}  # Open first bookmark"
+    puts "  #{"booker github".ljust(20).cyan}  # Search bookmarks for 'github'"
+    puts "  #{"booker --help".ljust(20).cyan}  # Show help"
+
+    exit 0
   end
 
   # parse and execute any command line options
   def parse_opt(args)
-    valid_opts = %w{--version -v --install -i --help -h
-    --complete -c --bookmark -b --search -s}
+    valid_opts = %w[--version -v --install -i --help -h
+      --complete -c --bookmark -b --search -s]
 
     nextarg = args.shift
-    errormsg = 'Error: '.red + "unrecognized option #{nextarg}"
-    pexit errormsg, 1 if ! (valid_opts.include? nextarg)
+    errormsg = "Error: ".red + "unrecognized option #{nextarg}"
+    pexit errormsg, 1 if !(valid_opts.include? nextarg)
 
     # forced bookmarking
-    if nextarg == '--bookmark' || nextarg == '-b'
+    if nextarg == "--bookmark" || nextarg == "-b"
       if args.first.nil?
-        pexit 'Error: '.red + 'booker --bookmark expects bookmark id', 1
+        pexit "Error: ".red + "booker --bookmark expects bookmark id", 1
       else
         open_bookmark args
       end
     end
 
     # autocompletion
-    if nextarg == '--complete' || nextarg == '-c'
-      allargs = args.join(' ')
+    if nextarg == "--complete" || nextarg == "-c"
+      allargs = args.join(" ")
       bm = Bookmarks.new(allargs)
       bm.autocomplete
     end
 
     # installation
-    if nextarg == '--install' || nextarg == '-i'
+    if nextarg == "--install" || nextarg == "-i"
       if !args.empty?
         install(args)
       else # do everything
-        install(%w{completion config bookmarks})
+        install(%w[completion config bookmarks])
       end
     end
 
     # forced searching
-    if nextarg == '--search' || nextarg == '-s'
-      pexit '--search requires an argument', 1 if args.empty?
-      allargs = args.join(' ')
+    if nextarg == "--search" || nextarg == "-s"
+      pexit "--search requires an argument", 1 if args.empty?
+      allargs = args.join(" ")
       open_search allargs
     end
 
     # print version information
-    version if nextarg == '--version' || nextarg == '-v'
+    version if nextarg == "--version" || nextarg == "-v"
 
     # needs some help
-    helper if nextarg == '--help' || nextarg == '-h'
+    helper if nextarg == "--help" || nextarg == "-h"
 
     exit 0 # dont parse_arg
   end # parse_opt
@@ -130,11 +207,11 @@ class Booker
     target = args.shift
     exit 0 if target.nil?
 
-    if /comp/i.match(target) # completion installation
+    if /comp/i.match?(target) # completion installation
       install_completion
-    elsif /book/i.match(target) # bookmarks installation
+    elsif /book/i.match?(target) # bookmarks installation
       install_bookmarks
-    elsif /conf/i.match(target) # default config file generation
+    elsif /conf/i.match?(target) # default config file generation
       install_config
     else # unknown argument passed into install
       pexit "Failure: ".red + "unknown installation option (#{target})", 1
@@ -146,64 +223,201 @@ class Booker
   def install_completion
     # check if zsh is even installed for this user
     begin
-      fpath = `zsh -c 'echo $fpath'`.split(' ')
+      fpath = `zsh -c 'echo $fpath'`.split(" ")
     rescue
       pexit "Failure: ".red + "zsh is probably not installed, could not find $fpath", 1
     end
 
-    # determine where to install completion function
-    fpath.each do |fp|
+    # Try user-writable directories first, then system directories
+    user_home = ENV["HOME"]
+    writable_dirs = fpath.select do |fp|
+      fp.start_with?(user_home) && File.directory?(fp) && File.writable?(fp)
+    end
+
+    # If no user-writable directories, try to create one
+    if writable_dirs.empty?
+      user_completion_dir = File.join(user_home, ".zsh", "completion")
       begin
-        File.open(fp + "/_booker", 'w') {|f| f.write(COMPLETION) }
+        FileUtils.mkdir_p(user_completion_dir)
+        writable_dirs << user_completion_dir
+        puts "Created user completion directory: #{user_completion_dir}".yel
+
+        # Auto-configure .zshrc if it exists
+        zshrc = File.join(user_home, ".zshrc")
+        if File.exist?(zshrc)
+          zshrc_content = File.read(zshrc)
+          if zshrc_content.include?(".zsh/completion")
+            puts "~/.zshrc already configured".grn
+          else
+            File.open(zshrc, "a") do |f|
+              f.puts "\n# Booker completion"
+              f.puts "fpath=(~/.zsh/completion $fpath)"
+              f.puts "autoload -Uz compinit && compinit"
+            end
+            puts "Added completion to ~/.zshrc".grn
+            puts "Run: ".yel + "source ~/.zshrc".cyan + " to activate"
+          end
+        else
+          puts "Add this to your ~/.zshrc: ".yel + "fpath=(~/.zsh/completion $fpath)".cyan
+        end
+      rescue => e
+        # Couldn't create user dir, try system dirs as fallback
+      end
+    end
+
+    # Try writable directories first, then all directories as fallback
+    dirs_to_try = writable_dirs + fpath.reject { |fp| writable_dirs.include?(fp) }
+
+    success = false
+    dirs_to_try.each do |fp|
+      next unless File.directory?(fp)
+
+      begin
+        completion_file = File.join(fp, "_booker")
+        File.write(completion_file, COMPLETION)
         system "zsh -c 'autoload -U _booker'"
         puts "Success: ".grn + "installed zsh autocompletion in #{fp}"
-        break # if this works, don't try anymore
-      rescue
-        puts "Failure: ".red + "could not write ZSH completion _booker script to $fpath (#{fp})"
+        success = true
+        break
+      rescue => e
+        # Try next directory silently
       end
     end
+
+    unless success
+      puts "Warning: ".yel + "Could not install ZSH completion to any directory in $fpath"
+      puts "Try manually: ".grn + "mkdir -p ~/.zsh/completion && booker --install completion"
+    end
   end
 
   def install_bookmarks
     # locate bookmarks file, show user, write to config?
-    puts 'searching for chrome bookmarks...'
+    puts "searching for chrome and firefox bookmarks..."
     begin
-      bms = [] # look for bookmarks
-      [ '/Library/Application Support/Google/Chrome',
-        '/AppData/Local/Google/Chrome/User Data/Default',
-        '/.config/chromium/Default/',
-        '/.config/google-chrome/Default/',
-      ].each do |f|
-        home = File.join(ENV['HOME'], f)
+      bms = [] # look for bookmarks with type info
+
+      # Search for Chrome bookmarks
+      ["Library/Application Support/Google/Chrome",
+        "AppData/Local/Google/Chrome/User Data/Default",
+        ".config/chromium/Default",
+        ".config/google-chrome/Default",
+        "snap/chromium/common/chromium",
+        "snap/chromium/current/.config/chromium"].each do |f|
+        home = File.join(ENV["HOME"], f)
         next if !FileTest.directory?(home)
         Find.find(home) do |file|
-          bms << file if /chrom.*bookmarks/i.match file
+          if /chrom.*bookmarks/i.match?(file)
+            bms << {path: file, type: :chrome}
+          end
+        end
+      end
+
+      # Search for Firefox bookmarks
+      firefox_paths = [
+        ".mozilla/firefox",                                # Linux
+        "snap/firefox/common/.mozilla/firefox",           # Linux (snap)
+        "Library/Application Support/Firefox",            # macOS
+        "AppData/Roaming/Mozilla/Firefox"                 # Windows
+      ]
+
+      firefox_paths.each do |f|
+        firefox_base = File.join(ENV["HOME"], f)
+        next if !FileTest.directory?(firefox_base)
+
+        profiles_ini = File.join(firefox_base, "profiles.ini")
+        next if !File.exist?(profiles_ini)
+
+        # Parse profiles.ini to find Firefox profiles
+        parse_firefox_profiles(profiles_ini, firefox_base).each do |db_path|
+          bms << {path: db_path, type: :firefox}
         end
       end
 
       if bms.empty? # no bookmarks found
-        puts "Failure: ".red + 'bookmarks file could not be found.'
+        puts "Failure: ".red + "bookmarks file could not be found."
         raise
-      else # have user select a file
-        puts 'select bookmarks file: '
-        bms.each_with_index {|bm, i| puts i.to_s.grn + " - " + bm }
-        selected = bms[gets.chomp.to_i]
-        puts 'Selected: '.yel + selected
+      elsif bms.length == 1
+        # Auto-select if only one source found
+        selected = bms.first[:path]
+        type_label = (bms.first[:type] == :chrome) ? "[Chrome]" : "[Firefox]"
+        puts "Found bookmark source: #{type_label} #{selected}".yel
+        puts "Selected: ".yel + selected
         BConfig.new.write(:bookmarks, selected)
         puts "Success: ".grn + "config file updated with your bookmarks"
+      else # have user select a file
+        puts "select bookmarks source: "
+
+        # Offer "ALL" as first option if multiple sources found
+        puts "0".grn + " - " + "[ALL SOURCES]".cyan + " (search across all browsers)"
+        offset = 1
+
+        bms.each_with_index do |bm, i|
+          type_label = (bm[:type] == :chrome) ? "[Chrome]".yel : "[Firefox]".blu
+          puts (i + offset).to_s.grn + " - " + type_label + " " + bm[:path]
+        end
+
+        input = gets
+        raise "No input provided" if input.nil?
+        selection = input.chomp.to_i
+
+        if selection == 0
+          # User selected "ALL" - save array of all paths
+          all_paths = bms.map { |bm| bm[:path] }
+          puts "Selected: ".yel + "All sources (#{bms.length} bookmark files)"
+          BConfig.new.write(:bookmarks, all_paths)
+          puts "Success: ".grn + "config file updated to search all bookmark sources"
+        else
+          # User selected single source
+          actual_index = selection - 1
+          selected = bms[actual_index][:path]
+          puts "Selected: ".yel + selected
+          BConfig.new.write(:bookmarks, selected)
+          puts "Success: ".grn + "config file updated with your bookmarks"
+        end
       end
-    rescue StandardError => e
+    rescue => e
       puts e.message
       pexit "Failure: ".red + "could not add bookmarks to config file ~/.booker", 1
     end
   end
 
-  def install_config
-    begin
-      BConfig.new.write
-      puts "Success: ".grn + "example config file written to ~/.booker"
-    rescue
-      pexit "Failure: ".red + "could not write example config file to ~/.booker", 1
+  def parse_firefox_profiles(ini_path, firefox_base)
+    profiles = []
+    current_profile = {}
+
+    File.readlines(ini_path).each do |line|
+      line = line.strip
+
+      # New profile section
+      if line.start_with?("[Profile")
+        # Save previous profile if it had a path
+        if current_profile[:path]
+          db_path = File.join(firefox_base, current_profile[:path], "places.sqlite")
+          profiles << db_path if File.exist?(db_path)
+        end
+        current_profile = {}
+
+      # Parse key=value pairs
+      elsif line.include?("=")
+        key, value = line.split("=", 2).map(&:strip)
+        current_profile[:path] = value if key == "Path"
+        current_profile[:name] = value if key == "Name"
+      end
+    end
+
+    # Don't forget the last profile
+    if current_profile[:path]
+      db_path = File.join(firefox_base, current_profile[:path], "places.sqlite")
+      profiles << db_path if File.exist?(db_path)
     end
+
+    profiles
+  end
+
+  def install_config
+    BConfig.new.write
+    puts "Success: ".grn + "example config file written to ~/.booker"
+  rescue
+    pexit "Failure: ".red + "could not write example config file to ~/.booker", 1
   end
 end