upm 0.1.14 → 0.1.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d35aa5412644879ebc18e848569dff6bf7274e09831a5733d63ab5fedffa1916
-  data.tar.gz: '09b5f1c4461fea7e092cc3ce630e7586c5bd127e849e173245f4c00c9df1d79f'
+  metadata.gz: 5643e0647bd7382b413354291acc5fa62ca282b21ea09a6ec7e714993fb0559c
+  data.tar.gz: 1370ad6461b00a72e138aaf0bed8d98e868372416c19b62cf8081db3a582467f
 SHA512:
-  metadata.gz: d7837f1491c9bdfa1c08fd8a5bcad5f265bbef08d26c0bdfc2b8ee526d1ad50106b6b598edb92c7af658c8c9df6602e26ac94516a7502261a368d405e3894bfc
-  data.tar.gz: 35a96cabe424135bafbab8b760b4cfc2de04b4c2d9811420c004625ab9cb8aea67bbfa1108c8ddaf68d3324eea94fe808b9ce3674100779d6ba4495c61588b75
+  metadata.gz: 9674e0839137df4b9efd4dc4730930df426c79b449b1b999ecd894bc48b00ab2df4ded3cbc915f2b333ed21aebc0f6eb7128eb6f36a5837e3c916a074e6f49e7
+  data.tar.gz: 996b34e98a0654a72fa3814d10101942fab1580448d9a34778baa95f3a93a6f551eee5b2b9803325f022377119c913fc827d57fca0275372646f69a04b27c44d

data/README.md

@@ -2,11 +2,33 @@
 
 ## Concept:
 
-Wraps all known package managers to provide a consistent and pretty interface, along with advanced features not supported by all tools, such as rollback and pinning.
+Wraps all known package managers to provide a consistent and pretty interface, along with advanced features not supported by all tools, such as:
+- install log
+- rollback
+- pinning
+- fuzzy search
+- containerization/sandboxing
+- learning what packages are cool (community statistics, user favorites)
 
-All tools will give you modern, pretty, colourful, piped-to-less output, and you'll only have to remember one consistent set of commands. It'll also prompt you with a text UI whenever faced with ambiguity.
+No matter what package manager you're using, you'll get a modern, pretty, colourful, output that's piped-to-less, and you only have to remember one consistent set of commands. It'll also prompt you with a text UI whenever faced with ambiguity.
 
-It will also allow users to maintain lists of their favorite packages (and sync them to some remote server), so that they can automatically install them whenever they setup a new machine. (This can include git repos full of dotfiles/scripts, to give the user a comfortable home environment regardless of which OS they're using.)
+You can maintain lists of your favorite packages (and sync them to some remote server), so that you can automatically install them whenever you setup a new machine. (This can include git repos full of dotfiles/scripts, to give you a comfortable home environment, regardless of which OS you're using.)
+
+## Reality:
+
+Currently, `upm` provides a consistent interface to a number of tools: apk (Alpine), apt (Debian/Ubuntu), guix, opkg (OpenWRT), pacman (Arch), pkg (FreeBSD), pkg_add (OpenBSD), pkgin (Solaris/NetBSD), xbps (Void), and yum (Fedora).
+
+All the tools support the basic operations (installing, searching, listing, removing), and some support more advanced features, like grabbing search results from the web and showing the installation logs, and the output is always paged to `less`.
+
+The more advanced features, like consistent output, colorization, fuzzy filtering, etc. are not yet implemented.
+
+## Installation:
+
+First, install Ruby. Then:
+
+```
+gem install upm
+```
 
 ## Usage:
 
@@ -18,25 +40,26 @@ u <command> <pkg>
 
 ## Commands:
 
-* `install`
-* `remove`
+* `install`/`add` - download and install a package
+* `remove`/`uninstall` - remove a previously installed package
 * `build` - compile a package from source and install it
 * `search` - using the fastest known API or service
 * `list` - show all packages, or the contents of a specific package
 * `info` - show metadata about a package
 * `sync`/`update` - retrieve the latest package list or manifest
 * `upgrade` - install new versions of all packages
-* `verfiy` - verify the integrity of installed files
+* `verify` - verify the integrity of installed files
 * `audit` - show known vulnerabilities for installed packages
 * `pin` - pinning a package means it won't be automatically upgraded
 * `rollback` - revert to an earlier version of a package (including its dependencies)
-* `log` - show history of package installs 
+* `log` - show history of package installs
 * `packagers` - detect installed package managers, and pick which ones upm should wrap
 * `sources`/`mirrors` - select remote repositories and mirrors
 * `clean` - clear out the local package cache
 * `monitor` - ad-hoc package manager for custom installations (like instmon)
 * `keys` - keyrings and package authentication
 * `default` - configure the action to take when no arguments are passed to "upm" (defaults to "os:update")
+* `switch` - set a default tool (eg: if you're on a system with both `apt-get` and `nix`, you can switch to `nix` so that you don't need to prefix every package with `nix:`)
 
 ### Any command that takes a package name can be prefixed with the package tool's namespace:
 
@@ -70,21 +93,23 @@ go:<pkg>,<pkg>,<pkg>
 * NetBSD: `pkgin`/`ports`
 * SmartOS/Illumos: `pkgin`
 * Windows: `apt-cyg`/`mingw-get`/`nuget`/`Windows Update`/(as-yet-not-created package manager, "winget")
-* Wine: `winetricks`
+* Wine/Proton/Steam: `winetricks`/`steam`
 * Ruby: `rubygems`
 * Python: `pip`/`easy_install`
-* Javascript: `npm`
-* Clojure: `leiningen`
-* Java: `gradle`
-* Erlang: `rebar`
-* Scala: `sbt`
+* Javascript/NodeJS: `npm`
 * Rust: `cargo`
+* Dart: `pub`
+* go: `go-get`
 * R: `cran`
+* Qt: `qpm`
 * Lua: `rocks`
 * Julia: `Pkg`
 * Haskell: `cabal`
+* Clojure: `leiningen`
+* Java: `gradle`
+* Erlang: `rebar`
+* Scala: `sbt`
 * Perl: `cpan`
-* go: `go-get`
 
 ...[and many more!](https://en.wikipedia.org/wiki/List_of_software_package_management_systems)
 
@@ -103,8 +128,68 @@ Rollback:
 
 ![pacman-rollback](https://raw.githubusercontent.com/epitron/scripts/master/screenshots/pacman-rollback.png)
 
+# Future Directions
+
 ## TODOs:
 
 * Use the pretty text-mode UI that passenger-install uses
 * Context-dependent operation
   * eg: if you're in a ruby project's directory, set the 'ruby' namespace to highest priority
+
+## Dotfiles
+
+* Manage and version-control dotfiles
+* Sync sqlite databases
+  * sqlitesync tool?
+
+## Themes
+
+* Font packs
+* Theme browser/downloader for GTK{2,3}, Qt, XFCE4, and Compiz
+  * Populate `~/.themes` and set ENVIRONMENT variables
+* Store/load from favorites
+
+## Containers, VMs, and Virtual Environments:
+
+Containers, VMs, and Virtual Environments are another pile of tools which do roughly the same thing: they gather together the dependencies for a specific program, or small set of programs, into a bundle, and create an isolated environment in which it can run.
+
+In the future, these could be wrapped by `ucm` (Universal Container Manager), if I get around to it.
+
+### Container tools to wrap:
+
+* Virtual Environments:
+  * Python: `virtualenv`
+  * Ruby: `bundler`
+  * Java: `gradle`
+  * NodeJS: `npm`
+* Containerized Applications/Systems:
+  * AppImage
+  * docker
+  * rkt
+  * snapd
+  * systemd
+  * podman
+  * nanobox
+  * SmartOS zones
+  * BSD jails (iocage)
+* Wine environments:
+  * wine prefixes
+  * playonlinuxs
+  * proton
+* Virtual Machines:
+  * qemu
+  * virtualbox
+  * VMware
+  * firecracker
+* Hypervisors:
+  * ESXi
+  * Xen
+  * Nova
+
+
+## Similar Projects
+
+* [PackageKit](https://en.wikipedia.org/wiki/PackageKit)
+* [libraries.io](https://libraries.io)
+* [pkgs.org](https://pkgs.org)
+* [Repology](https://repology.org)

data/TODO.md

@@ -1,19 +1,33 @@
 # TODO
 
-## Performance
+## UI
+* fzf/pick
+* scrapers for web-based search engines (especially for "files in packages")
+
+## Options
+* Proper option/command parser
+* Verbose mode (prints `run` commands)
+
+## DSL
+* Call commands from within other commands, or specify dependencies (eg: command "install", "pkg install", depends: "update" )
+* DSL setting defaults (eg: cache_dir "~/.cache/upm")
+* Some commands require special packages (eg: "command 'locate', depends: 'pkgfile'") which have their own syncable databases
+  |_ offer to install these dependencies (and sync them (periodically))
+  |_ web-based search is even nicer
+* Page multi-commands (eg: 'args.each { run ..., paged: true }' should all output to the same pager)
+  |_ 'run ..., pager: IO'? will that break grep?
 
-It's currently very clunky on the rpi2.
+## Performance
+* RPi2 is very clunky
+  |_ rewrite in... C? rust? go? lua?
 
 ## Custom help for command
-
 eg: command "something", help: "does stuff", root: true do ... end
 
 ## Pipes and filters
-
 * `Tool::DSL#run` is currently somewhat awkward; it would be simpler if returned an `Enumerator`, which could then be filtered (ie: highlight/grep), or concatenated to other `Enumerator`s.
 
 ## Streaming pipes with colours
-
 * Make the `run` command able to grep the output while streaming the results to the screen.
 * Make run pretend to be a tty, so I don't need `--color=always`.
 * Use spawn, like so:
@@ -24,7 +38,6 @@ spawn(*%w[tr a-z A-Z], in: r)
 ```
 
 ## More package managers
-
 Currently missing:
 * RedHat/Fedora/CentOS
 * OSX
@@ -33,31 +46,26 @@ Currently missing:
 * SuSE
 
 ## Dependency-fetching features
-
 * Use upm to fetch dependencies for any library or script, across any language.
 * Some kind of manifest file (or personifest, to be politically correct)
 * This is a little like bundler, npm, etc., but for any type of package.
 
 ## Ability to install any package from any OS to the user's home directory
-
 Slurps up the packages and their dependencies, then unpacks them into ~/.upm/{bin,lib} or something.
 (Like nix?)
 
 Related tool: intoli/exodus
 
 ## fzf
-
 Use fzf for "list" output (or other commands that require selecting, like "remove")
 
 ## Commandline argument parser
-
 * Add options to commands:
   * upm upgrade --download-only
   * upm install --help
   * upm help install
 
 ## Figure out how to integrate language package managers
-
 * The packages that you can get through gem/pip/luarocks/etc. are often duplicated in the OS-level package managers. Should there be a preference?
 * Should the search command show matches from all available package tools? (There could be a configure step where the user says which package managers should be included, and which have preference)
 * Possibilites: 
@@ -72,36 +80,28 @@ Use fzf for "list" output (or other commands that require selecting, like "remov
 * `upm help --ruby` should show available ruby commands
 
 ## Give identical output on every platform
-
 * Requires parsing the output of every command into a canonical format, or reading the package databases directly.
 
 ## apt: Integrate 'acs' wrapper script
 
 ## Evaluate UPM::Tool.new block in an instance of an anonymous subclass of UPM::Tool
-
 This will allow tools to create classes and modules inside the UPM::Tool block without namespace collisions
 
 ## Themes?
-
 Why not!
 
 ## Mirror Selector
-
 Do a ping test on available mirrors, and use fzf to select.
 
 ## Interrupt catcher
-
 Don't print backtrace when ^C is pressed.
 
 ## Tests
-
 Create fake OS environments that you can chroot into and run upm to test it out.
 
 
-
 # DONE
 
 ## Abbrev cmds
-
 * eg: upm install => upm i => u i
 

data/VERSION

@@ -1 +1 @@
-0.1.14
+0.1.18

data/bin/upm

@@ -9,13 +9,16 @@ unless tool = UPM::Tool.for_os
   exit 1
 end
 
-command, *args = ARGV
-
-if command.nil?
+if ARGV.any? { |arg| ["help", "version", "--help", "--version", "-h", "-v"].include? arg }
   tool.help
 else
-  begin
-    tool.call_command command, *args
-  rescue Interrupt
+  command, *args = ARGV
+  if command.nil?
+    tool.help
+  else
+    begin
+      tool.call_command command, *args
+    rescue Interrupt
+    end
   end
-end
+end

data/design/Favorite Packages.md

@@ -0,0 +1,7 @@
+# Favorite Packages
+
+## Concept
+
+The user can create their own package groups manually, or dump of their current desktop's package selecitons and organize them.
+
+

data/design/Fuzzy Installer.md

@@ -0,0 +1,28 @@
+# Fuzzy Installer
+
+## Concept 
+
+'upm install <pkg query>' performs a search
+
+If there's one match, install it; if there are multiple matches, show ranked results and let the user pick one (fzf-like picker, but with a hotkey that can expand descriptions).
+
+Ranking of packages by source use statistics and heuristics
+- Which version is newest?
+- Which version is more stable?
+- What has the user picked in the past? (eg: a distro's global ruby-<gem> package vs a globally installed gem vs a locally installed gem)
+- What tools are installed? (docker? gem?)
+- Which package is less likely to break stuff? (some package managers are better than others (*cough*pip))
+- Is it a service that should be instaled in a container?
+
+## Depends on
+
+- A database of package aliases
+- A ranking algorithm
+	- Package type prioritization (manually specified or machine learned, per-package rules based on all users who installed it)
+	- 
+- Distributed statistics
+	- Users can anonymously donate their stats
+	- Stats are all public
+	- Ranking algorithm can run locally or on a distributed system
+
+# 

data/design/Updates Grouped Together for Readability.md

@@ -0,0 +1,18 @@
+# Updates Grouped Together for Readability
+
+## Concept
+
+The design of package update screens is pretty abysmal -- usually just a big blob of package names and versions. This can be improved.
+
+## Groups
+
+Packages can be grouped by any of the following:
+
+- semantic version (MAJOR.MINOR.PATCH):
+  - MAJOR: incompatible API changes
+  - MINOR: backwards-compatible features added
+  - PATCH: bugfixes
+- package's category/tags
+- which repository the package came from
+- who packaged it
+- a tree-view of package dependencies (useful for seeing dependency relationships during package updates)

data/lib/upm/core_ext/file.rb

@@ -0,0 +1,159 @@
+#
+# Beginning of File reached! (Raised when reading a file backwards.)
+#
+class BOFError < Exception; end
+
+class File
+
+  #
+  # A streaming `reverse_each` implementation. (For large files, it's faster and uses less memory.)
+  #
+  def reverse_each(&block)
+    return to_enum(:reverse_each) unless block_given?
+
+    seek_end
+    reverse_each_from_current_pos(&block)
+  end
+  alias_method :reverse_each_line, :reverse_each
+
+  #
+  # Read the previous `length` bytes. After the read, `pos` will be at the beginning of the region that you just read.
+  # Returns `nil` when the beginning of the file is reached.
+  #
+  # If the `block_aligned` argument is `true`, reads will always be aligned to file positions which are multiples of 512 bytes.
+  # (This should increase performance slightly.)
+  #
+  def reverse_read(length, block_aligned=false)
+    raise "length must be a multiple of 512" if block_aligned and length % 512 != 0
+
+    end_pos = pos
+    return nil if end_pos == 0
+
+    if block_aligned
+      misalignment = end_pos % length
+      length      += misalignment
+    end
+
+    if length >= end_pos # this read will take us to the beginning of the file
+      seek(0)
+    else
+      seek(-length, IO::SEEK_CUR)
+    end
+
+    start_pos = pos
+    data      = read(end_pos - start_pos)
+    seek(start_pos)
+
+    data
+  end
+
+  #
+  # Read each line of file backwards (from the current position.)
+  #
+  def reverse_each_from_current_pos
+    return to_enum(:reverse_each_from_current_pos) unless block_given?
+
+    # read the rest of the current line, in case we started in the middle of a line
+    start_pos = pos
+    fragment = readline rescue ""
+    seek(start_pos)
+
+    while data = reverse_read(4096)
+      lines = data.each_line.to_a
+      lines.last << fragment unless lines.last[-1] == "\n"
+
+      fragment = lines.first
+
+      lines[1..-1].reverse_each { |line| yield line }
+    end
+
+    yield fragment
+  end
+
+  #
+  # Seek to `EOF`
+  #
+  def seek_end
+    seek(0, IO::SEEK_END)
+  end
+
+  #
+  # Seek to `BOF`
+  #
+  def seek_start
+    seek(0)
+  end
+
+  #
+  # Read the previous line (leaving `pos` at the beginning of the string that was read.)
+  #
+  def reverse_readline
+    raise BOFError.new("beginning of file reached") if pos == 0
+
+    seek_backwards_to("\n", 512, -2)
+    new_pos = pos
+    data = readline
+    seek(new_pos)
+    data
+  end
+
+  #
+  # Scan through the file until `string` is found, and set the IO's +pos+ to the first character of the matched string.
+  #
+  def seek_to(string, blocksize=512)
+    raise "Error: blocksize must be at least as large as the string" if blocksize < string.size
+
+    loop do
+      data = read(blocksize)
+
+      if index = data.index(string)
+        seek(-(data.size - index), IO::SEEK_CUR)
+        break
+      elsif eof?
+        return nil
+      else
+        seek(-(string.size - 1), IO::SEEK_CUR)
+      end
+    end
+
+    pos
+  end
+
+  #
+  # Scan backwards in the file until `string` is found, and set the IO's +pos+ to the first character after the matched string.
+  #
+  def seek_backwards_to(string, blocksize=512, rindex_end=-1)
+    raise "Error: blocksize must be at least as large as the string" if blocksize < string.size
+
+    loop do
+      data = reverse_read(blocksize)
+
+      if index = data.rindex(string, rindex_end)
+        seek(index+string.size, IO::SEEK_CUR)
+        break
+      elsif pos == 0
+        return nil
+      else
+        seek(string.size - 1, IO::SEEK_CUR)
+      end
+    end
+
+    pos
+  end
+  alias_method :reverse_seek_to, :seek_backwards_to
+
+  #
+  # Iterate over each line of the file, yielding the line and the byte offset of the start of the line in the file
+  #
+  def each_line_with_offset
+    return to_enum(:each_line_with_offset) unless block_given?
+
+    offset = 0
+
+    each_line do |line|
+      yield line, offset
+      offset = tell
+    end
+  end
+
+end

data/lib/upm/tool.rb

@@ -16,6 +16,8 @@ module UPM
 
     include UPM::Tool::DSL
 
+    # TODO: Show unlisted commands
+
     COMMAND_HELP = {
       "install"          => "install a package",
       "remove/uninstall" => "remove a package",
@@ -23,43 +25,57 @@ module UPM
       "search-sources"   => "search package source (for use with 'build' command)",
       "build"            => "build a package from source and install it",
       "list"             => "list installed packages (or search their names if extra arguments are supplied)",
-      "info"             => "show metadata about a package",
+      "selection/manual" => "list manually installed packages", # this should probably be a `list` option ("upm list --manually-added" or smth (would be nice: rewrite in go and use ipfs' arg parsing library))
+      "files"            => "list files in a package",
+      "rdeps/depends"    => "reverse dependencies (which packages depend on this package?)",
+      "locate"           => "search contents of packages (local or remote)",
+      "info/show"        => "show metadata about a package",
       "update/sync"      => "retrieve the latest package list or manifest",
       "upgrade"          => "update package list and install updates",
+      "selfupdate"       => "update the package manager",
       "download"         => "download package list and updates, but don't insatall them",
       "pin"              => "pinning a package means it won't be automatically upgraded",
       "rollback"         => "revert to an earlier version of a package (including its dependencies)",
       "verify/check"     => "verify the integrity of packages' files on the filesystem",
-      "audit/vuln"       => "show known vulnerabilities in installed packages",
+      "repair"           => "fix corrupted packages",
+      "audit/vulns"      => "show known vulnerabilities in installed packages",
       "log"              => "show history of package installs",
       "packagers"        => "detect installed package managers, and pick which ones upm should wrap",
-      "mirrors/sources"  => "manage remote repositories and mirrors",
       "clean"            => "clear out the local package cache",
       "monitor"          => "ad-hoc package manager for custom installations (like instmon)",
       "keys"             => "keyrings and package authentication",
       "default"          => "configure the action to take when no arguments are passed to 'upm' (defaults to 'os:update')",
       "stats"            => "show statistics about package database(s)",
+      "repos/mirrors/sources/channels" => "manage subscriptions to remote repositories/mirrors/channels",
     }
 
     ALIASES = {
-      "file"    => "files",
-      "sync"    => "update",
-      "sources" => "mirrors",
-      "show"    => "info",
-      "vuln"    => "audit",
-      "vulns"   => "audit",
-      "check"   => "verify",
-      "u"       => "upgrade",
-      "i"       => "install",
-      "d"       => "download",
-      "s"       => "search",
-      "f"       => "files",
-      "r"       => "remove",
+      "u"             => "upgrade",
+      "i"             => "install",
+      "d"             => "download",
+      "s"             => "search",
+      "f"             => "files",
+      "r"             => "remove",
+      "m"             => "mirrors",
+      "file"          => "files",
+      "vuln"          => "audit",
       "source-search" => "search-sources",
     }
 
+    COMMAND_HELP.keys.each do |key|
+      cmd, *alts = key.split("/")
+      alts.each do |alt|
+        ALIASES[alt] = cmd
+      end
+    end
+
     def initialize(name, &block)
       @name = name
+
+      set_default :cache_dir, "~/.cache/upm"
+      set_default :config_dir, "~/.cache/upm"
+      set_default :max_database_age, 15*60 # 15 minutes
+
       instance_eval(&block)
 
       @@tools[name] = self

data/lib/upm/tool_class_methods.rb

@@ -2,6 +2,11 @@ module UPM
   class Tool
     class << self
 
+      def error(message)
+        $stderr.puts message
+        exit 1
+      end
+
       def tools; @@tools; end
 
       def register_tools!
@@ -10,11 +15,12 @@ module UPM
 
       def os_release
         @os_release ||= begin
-          open("/etc/os-release") do |io|
+          pairs = open("/etc/os-release") do |io|
             io.read.scan(/^(\w+)="?(.+?)"?$/)
-          end.to_h
+          end
+          Hash[pairs]
         rescue Errno::ENOENT
-          {}
+          nil
         end
       end
 
@@ -25,13 +31,18 @@ module UPM
         else
           # `uname -s` => Darwin|FreeBSD|OpenBSD
           # `uname -o` => Android|Cygwin
-          [`uname -s`, `uname -o`].map(&:chomp).uniq
+          names = [`uname -s`]
+          names << `uname -o` unless names.first =~ /OpenBSD/
+          names.map(&:chomp).uniq
         end
       end
 
       def nice_os_name
-        os_release.values_at("PRETTY_NAME", "NAME", "ID", "ID_LIKE").first || 
-          (`uname -o`.chomp rescue nil)
+        if os_release
+          os_release.values_at("PRETTY_NAME", "NAME", "ID", "ID_LIKE").first
+        else
+          (`uname -o 2> /dev/null`.chomp rescue nil)
+        end
       end
 
       def installed
@@ -44,14 +55,14 @@ module UPM
         tool = nil
 
         if os_names.any?
-          tool = @@tools.find { |name, tool| os_names.any? { |name| tool.os.include? name } }&.last
+          tool = @@tools.find { |name, tool| os_names.any? { |name| tool.os&.include? name } }
         end
 
         if tool.nil?
-          tool = @@tools.find { |name, tool| File.which(tool.identifying_binary) }&.last
+          tool = @@tools.find { |name, tool| File.which(tool.identifying_binary) }
         end
 
-        tool
+        tool&.last
       end
 
     end

data/lib/upm/tool_dsl.rb

@@ -1,3 +1,6 @@
+require 'pathname'
+require 'fileutils'
+
 module UPM
   class Tool
     module DSL
@@ -13,6 +16,28 @@ module UPM
         @prefix = name
       end
 
+      def os(*args)
+        args.any? ? @os = args : @os
+      end
+
+      def max_database_age(age)
+        @max_database_age = age.to_i
+      end
+
+      def cache_dir(dir)
+        @cache_dir = Pathname.new(dir).expand_path
+        @cache_dir.mkpath unless @cache_dir.exist?
+      end
+
+      def config_dir(dir)
+        @config_dir = Pathname.new(dir).expand_path
+        @config_dir.mkpath unless @config_dir.exist?
+      end
+
+      def set_default(key, value)
+        send(key, value)
+      end
+
       def command(name, shell_command=nil, root: false, paged: false, highlight: nil, &block)
         @cmds ||= {}
 
@@ -38,16 +63,10 @@ module UPM
           end
 
         else
-
           raise "Error: Must supply a block or shell command"
-
         end
       end
 
-      def os(*names)
-        names.any? ? @os = names : @os
-      end
-
       ## Helpers
 
       def run(*args, root: false, paged: false, grep: nil, highlight: nil, sort: false)
@@ -139,7 +158,30 @@ module UPM
         end
       end
 
+      def database_lastupdate_file
+        raise "Error: Tool 'name' is not set" unless @name
+        raise "Error: 'cache_dir' is not set" unless @cache_dir
+        @cache_dir/"#{@name}-last-update"
+      end
+
+      def database_updated!
+        FileUtils.touch(database_lastupdate_file)
+      end
+
+      def database_lastupdate
+        database_lastupdate_file.exist? ? File.mtime(database_lastupdate_file) : 0
+      end
+
+      def database_age
+        Time.now.to_i - database_lastupdate.to_i
+      end
+
+      def database_needs_updating?
+        database_age > @max_database_age
+      end
+
       def help
+        puts "    UPM version: #{File.read("#{__dir__}/../../VERSION")}"
         if osname = Tool.nice_os_name
           puts "    Detected OS: #{osname}"
         end

data/lib/upm/tools/guix.rb

@@ -0,0 +1,60 @@
+class GUIXPackage < Struct.new(:name, :version, :out, :path)
+  def self.from_line(line)
+    new(*line.chomp.split)
+  end
+
+  def self.installed
+    @installed_packages ||= IO.popen(["guix", "package", "--list-installed"]) { |io| io.each_line.map { |line| GUIXPackage.from_line(line) } }
+  end
+
+  def self.avaialble
+    @available_packages ||= IO.popen(["guix", "package", "--list-available"]) { |io| io.each_line.map { |line| GUIXPackage.from_line(line) } }
+  end
+
+  def installed?
+    !!path[%r{^/gnu/store/}]
+  end
+end
+
+
+UPM::Tool.new "guix" do
+
+  identifying_binary "guix"
+
+  command "install",    "guix install"
+  command "remove",     "guix remove"
+  command "info",       "guix show"
+  command "rollback",   "guix package –roll-back"
+  command "selfupdate", "guix pull"
+  command "upgrade",    "guix package --upgrade"
+
+  command "files", paged: true do |args|
+    error "Ope, you forgot the package name!" if args.empty?
+
+    args.each do |arg|
+      if pkg = GUIXPackage.installed.find { |pkg| pkg.name == arg }
+        run "find", pkg.path, paged: true
+      else
+        error "#{arg.inspect} not found"
+      end
+    end
+  end
+
+  command "search" do |args|
+    query           = args.join(" ")
+    highlight_query = args.join(".+")
+    grep_query      = args.join(".+")
+    run "guix", "package", "--list-available", sort: true, grep: grep_query, paged: true, highlight: highlight_query
+  end
+
+  command "list" do |args|
+    if args.any?
+      highlight_query = args.join(".+")
+      grep_query = /#{highlight_query}/
+      run "guix", "package", "--list-installed", grep: grep_query, highlight: highlight_query, paged: true
+    else
+      run "guix", "package", "--list-installed", paged: true
+    end
+  end
+
+end

data/lib/upm/tools/opkg.rb

@@ -0,0 +1,26 @@
+UPM::Tool.new "opkg" do
+
+  os "openwrt", "lede"
+
+  command "install", "opkg install",      root: true
+  command "update",  "opkg update",       root: true
+  command "upgrade", root: true do |args|
+    pkgs = `opkg list-upgradable`.each_line.map { |line| line.split.first }
+    run "opkg", "upgrade", *pkgs
+  end
+
+  command "search" do |args|
+    query = args.join
+    run "opkg", "list", grep: query, paged: true
+  end
+
+  command "list" do |args|
+    if args.any?
+      query = args.join
+      run "opkg", "list-installed", grep: query, paged: true
+    else
+      run "opkg", "list-installed", paged: true
+    end
+  end
+
+end

data/lib/upm/tools/pacman.rb

@@ -1,12 +1,11 @@
 UPM::Tool.new "pacman" do
-
   os "arch"
 
   bin = ["pacman", "--color=always"]
 
   command "install", [*bin, "-S"],   root: true
   command "update",  [*bin, "-Sy"],  root: true
-  command "upgrade", [*bin, "-Syu"], root: true
+  command "upgrade", [*bin, "-Syu", "--noconfirm"], root: true
   command "remove",  [*bin, "-R"],   root: true
 
   command "verify", root: true do |args|
@@ -17,6 +16,7 @@ UPM::Tool.new "pacman" do
   command "audit",  "arch-audit",  paged: true
   command "files",  [*bin, "-Ql"], paged: true
   command "search", [*bin, "-Ss"], paged: true, highlight: true
+  command "locate", ["pkgfile", "-r"], paged: true
 
   command "info" do |args|
     run(*bin, "-Qi", *args, paged: true) || run(*bin, "-Si", *args, paged: true)
@@ -33,6 +33,7 @@ UPM::Tool.new "pacman" do
 
   command "mirrors" do
     print_files("/etc/pacman.d/mirrorlist", exclude: /^(#|$)/)
+    print_files("/etc/pacman.conf", include: /^Server\s*=/, exclude: /^(#|$)/)
   end
 
   command "depends" do |args|
@@ -105,4 +106,39 @@ UPM::Tool.new "pacman" do
 
   end
 
+  command "rdeps" do |args|
+    packages_that_depend_on = proc do |package|
+      result = []
+
+      # [`pacman -Sii #{package}`, `pacman -Qi #{package}`].each do |output|
+      [`pacman -Sii #{package}`].each do |output|
+        output.each_line do |l|
+          if l =~ /Required By\s+: (.+)/
+            result += $1.strip.split unless $1["None"]
+            break
+          end
+        end
+      end
+
+      result
+    end
+
+    args.each do |package|
+      puts "<8>=== <14>#{package} <8>============".colorize
+      puts
+
+      packages = packages_that_depend_on.call package
+
+      if packages.empty?
+        puts "  <12>None".colorize
+      else
+        run "pacman", "-Ss", "^(#{packages.join '|'})$" # upstream packages
+        run "pacman", "-Qs", "^(#{packages.join '|'})$" # packages that are only installed locally
+      end
+
+      puts
+    end
+  end
 end
+
+

data/lib/upm/tools/pkg.rb

@@ -1,24 +1,69 @@
-require 'upm/freshports_search'
-
 UPM::Tool.new "pkg" do
 
   os "FreeBSD"
 
-  command "install", "pkg install", root: true
-  command "update",  "pkg update",  root: true
-  command "upgrade", "pkg upgrade", root: true
-  command "info",    "pkg clean",   root: true
+  command "update", root: true do
+    if database_needs_updating?
+      run "pkg", "update" 
+      database_updated!
+    else
+      puts "Database has already been updated recently. Skipping."
+    end
+  end
+
+  command "install", root: true do |args|
+    call_command "update"
+    run "pkg", "install", "--no-repo-update", *args
+  end
+
+  command "upgrade", root: true do
+    call_command "update"
+    run "pkg", "upgrade", "--no-repo-update"
+  end
+
+  command "remove",  "pkg remove",  root: true
   command "audit",   "pkg audit",   root: true
+  command "clean",   "pkg clean -a",root: true
   command "verify",  "pkg check --checksums", root: true
+  command "which",   "pkg which"
+
+  command "files" do |args|
+    if args.empty?
+      run "pkg", "info", "--list-files", "--all", paged: true
+    else
+      run "pkg", "list", *args, paged: true
+    end
+  end
+
+  # the "pkg-provides" plugin is similar to arch's "pkgfile" (requires updates), and needs to be added to the plugins section of pkg's config ("pkg plugins" shows loaded plugins)
+  command "provides" do |args|
+    run "pkg", "info", "--list-files", "--all", grep: /#{args.join(".+")}/, highlight: true
+  end
 
-  command "files",   "pkg list",    paged: true
   command "search",  "pkg search",  paged: true, highlight: true
   command "search-sources" do |*args|
+    require 'upm/freshports_search'
     query = args.join(" ")
     FreshportsSearch.new.search!(query)
   end
 
-  command "log", "grep pkg: /var/log/messages", paged: true
+  # command "log", "grep -E 'pkg.+installed' /var/log/messages", paged: true
+  command "log" do
+    require 'upm/core_ext/file'
+    lesspipe do |less|
+      open("/var/log/messages").reverse_each_line do |line|
+        # Jan 19 18:25:21 freebsd pkg[815]: pcre-8.43_2 installed
+        # Apr  1 16:55:58 freebsd pkg[73957]: irssi-1.2.2,1 installed
+        if line =~ /^(\S+\s+\S+\s+\S+) (\S+) pkg(?:\[\d+\])?: (\S+)-(\S+) installed/
+          timestamp = DateTime.parse($1)
+          host = $2
+          pkgname = $3
+          pkgver = $4
+          less.puts "#{timestamp} | #{pkgname} #{pkgver}"
+        end
+      end
+    end
+  end
 
   command "build" do |*args|
     # svn checkout --depth empty svn://svn.freebsd.org/ports/head /usr/ports
@@ -48,4 +93,10 @@ UPM::Tool.new "pkg" do
     print_files("/etc/pkg/FreeBSD.conf", exclude: /^(#|$)/)
   end
 
+  # pkg clean # cleans /var/cache/pkg/
+  # rm -rf /var/cache/pkg/* # just remove it all
+  # pkg update -f # forces update  of repository catalog
+  # rm /var/db/pkg/repo-*.sqlite # removes all remote repository catalogs
+  # pkg bootstrap -f # forces reinstall of pkg
+
 end

data/lib/upm/tools/pkg_add.rb

@@ -0,0 +1,24 @@
+UPM::Tool.new "pkg_add" do
+
+  os "OpenBSD"
+
+  command "install",  "pkg_add",      root: true
+  command "remove",   "pkg_delete",   root: true
+  command "upgrade",  "pkg_add -u",   root: true
+  command "clean",    "yum clean",    root: true
+  command "info",     "pkg_info",     paged: true
+  command "files",    "pkg_info -L",  paged: true
+  command "search",   "pkg_info -Q",  paged: true
+  command "verify",   "pkg_check"
+
+  command "list" do |args|
+    if args.any?
+      highlight_query = args.join(".+")
+      grep_query = /#{highlight_query}/
+      run "pkg_info", grep: grep_query, highlight: highlight_query, paged: true
+    else
+      run "pkg_info", paged: true
+    end
+  end
+
+end

data/lib/upm/tools/pkgin.rb

@@ -0,0 +1,49 @@
+UPM::Tool.new "pkgin" do
+
+  os "MINIX", "NetBSD"
+
+  command "install", "pkgin install", root: true
+  command "update",  "pkgin update",  root: true
+  command "upgrade", "pkgin upgrade", root: true
+  command "info",    "pkgin clean",   root: true
+  command "audit",   "pkgin audit",   root: true
+  command "verify",  "pkgin check --checksums", root: true
+
+  command "files",   "pkgin list",    paged: true
+  command "search",  "pkgin search",  paged: true, highlight: true
+  command "search-sources" do |*args|
+    query = args.join(" ")
+    FreshportsSearch.new.search!(query)
+  end
+
+  command "log", "grep pkg: /var/log/messages", paged: true
+
+  command "build" do |*args|
+    # svn checkout --depth empty svn://svn.freebsd.org/ports/head /usr/ports
+    # cd /usr/ports
+    # svn update --set-depth files
+    # svn update Mk
+    # svn update Templates
+    # svn update Tools
+    # svn update --set-depth files $category
+    # cd $category
+    # svn update $port
+    puts "Not implemented"
+  end
+
+  command "info",    "pkg info",    paged: true
+
+  command "list" do |args|
+    if args.any?
+      query = args.join
+      run "pkg", "info", grep: query, highlight: query, paged: true
+    else
+      run "pkg", "info", paged: true
+    end
+  end
+
+  command "mirrors" do
+    print_files("/etc/pkg/FreeBSD.conf", exclude: /^(#|$)/)
+  end
+
+end

data/lib/upm/tools/xbps.rb

@@ -4,12 +4,28 @@ UPM::Tool.new "xbps" do
 
   identifying_binary "xbps-install"
 
-  command "install", "xbps-install",      root: true
-  command "update",  "xbps-install -S",   root: true
-  command "upgrade", "xbps-install -Su",  root: true
+  command "install",   "xbps-install",      root: true
+  command "remove",    "xbps-remove",       root: true
+  command "update",    "xbps-install -S",   root: true
+  command "upgrade",   "xbps-install -Su",  root: true
+  command "files",     "xbps-query -f",     paged: true
+  command "locate",    "xlocate",           paged: true
+  command "selection", "xbps-query -m",     paged: true
+  command "rdeps",     "xbps-query -X",     paged: true
 
-  command "files",   "xbps-query -f",           paged: true
-  command "search",  "xbps-query --regex -Rs",  paged: true
+  command "info" do |args|
+    args.each do |arg|
+      unless run("xbps-query", "-S", arg)
+        run("xbps-query", "-R", "-S", arg)
+      end
+      puts
+    end
+  end
+
+  command "search" do |args|
+     query = args.join(".*")
+     run "xbps-query", "--regex", "-Rs", query, highlight: /(#{ args.join("|") })/i, paged: true
+  end
   
   command "list" do |args|
     if args.any?
@@ -20,4 +36,49 @@ UPM::Tool.new "xbps" do
     end
   end
 
+
+
+  class XBPSPackage < Struct.new(:name, :version, :date)
+    def self.from_line(line)
+      # zd1211-firmware-1.5_3: 2021-09-01 15:22 UTC
+      if line =~ /^([\w\-]+)-([\d\.]+_\d+): (.+)$/
+        name, version, date = $1, $2, $3
+        date = DateTime.parse($3)
+        new(name, version, date)
+      else
+        nil
+      end
+    end
+
+    def to_s
+      "[#{date.strftime("%Y-%m-%d %H:%M:%S")}] #{name} #{version}"
+    end
+  end
+
+  command "log" do |args|
+    fakedata = %{
+	xset-1.2.4_1: 2021-11-05 15:03 UTC
+	xsetroot-1.1.2_1: 2021-11-05 15:03 UTC
+	xtools-0.63_1: 2021-11-05 16:36 UTC
+	xtrans-1.4.0_2: 2021-11-05 15:26 UTC
+	xvidcore-1.3.7_1: 2021-11-05 16:45 UTC
+	xvinfo-1.1.4_2: 2021-11-05 15:03 UTC
+	xwd-1.0.8_1: 2021-11-05 15:03 UTC
+	xwininfo-1.1.5_1: 2021-11-05 15:03 UTC
+	xwud-1.0.5_1: 2021-11-05 15:03 UTC
+	xz-5.2.5_2: 2021-11-05 15:12 UTC
+	zd1211-firmware-1.5_3: 2021-09-01 15:22 UTC
+	zip-3.0_6: 2021-11-05 17:45 UTC
+	zlib-1.2.11_4: 2021-09-01 14:14 UTC
+	zlib-devel-1.2.11_4: 2021-11-05 15:26 UTC
+    }
+
+    data = IO.popen(["xbps-query", "-p", "install-date", "-s", ""], &:read)
+    packages = data.each_line.map do |line|
+      XBPSPackage.from_line(line.strip)
+    end.compact
+    packages.sort_by!(&:date)
+    packages.each { |pkg| puts pkg }
+  end
 end
+    

data/lib/upm/tools/yum.rb

@@ -0,0 +1,27 @@
+UPM::Tool.new "yum" do
+
+  os "centos", "fedora", "rhel"
+
+  command "install", "yum install",    root: true
+  command "remove",  "yum remove",     root: true
+  command "update",  "yum updateinfo", root: true
+  command "upgrade", "yum update",     root: true
+  command "clean",   "yum clean",      root: true
+
+  command "files",   "rpm -ql",  paged: true
+  command "search" do |args|
+    query = args.join(".+")
+    run "yum", "search", *args, sort: true, paged: true, highlight: query
+  end
+
+  command "list" do |args|
+    if args.any?
+      highlight_query = args.join(".+")
+      grep_query = /#{highlight_query}/
+      run "yum", "list", "installed", grep: grep_query, highlight: highlight_query, paged: true
+    else
+      run "yum", "list", "installed", paged: true
+    end
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: upm
 version: !ruby/object:Gem::Version
-  version: 0.1.14
+  version: 0.1.18
 platform: ruby
 authors:
 - epitron
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-07-05 00:00:00.000000000 Z
+date: 2021-11-08 00:00:00.000000000 Z
 dependencies: []
 description: Wrap all known command-line package tools with a consistent and pretty
   interface.
@@ -28,9 +28,13 @@ files:
 - TODO.md
 - VERSION
 - bin/upm
+- design/Favorite Packages.md
+- design/Fuzzy Installer.md
+- design/Updates Grouped Together for Readability.md
 - lib/upm.rb
 - lib/upm/colored.rb
 - lib/upm/core_ext.rb
+- lib/upm/core_ext/file.rb
 - lib/upm/freshports_search.rb
 - lib/upm/lesspipe.rb
 - lib/upm/log_parser.rb
@@ -40,16 +44,21 @@ files:
 - lib/upm/tool_dsl.rb
 - lib/upm/tools/apk.rb
 - lib/upm/tools/apt.rb
+- lib/upm/tools/guix.rb
+- lib/upm/tools/opkg.rb
 - lib/upm/tools/pacman.rb
 - lib/upm/tools/pkg.rb
+- lib/upm/tools/pkg_add.rb
+- lib/upm/tools/pkgin.rb
 - lib/upm/tools/xbps.rb
+- lib/upm/tools/yum.rb
 - spec/core_ext_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/epitron/upm/
 licenses:
 - WTFPL
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -64,9 +73,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: Universal Package Manager
 test_files: []