upm 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5dd0714a5b73fc48e824d842aa8d4eb3f09f4c6cf3b72d3da04a9837bb8ce661
-  data.tar.gz: b2b9f7acd21647b482ef8cc799fd5df72832a6500fad45a81026aa9cf567726f
+  metadata.gz: f8a190f9686ce55b16d74b0ff642047a17e19683187a40d40cebfc542262fcff
+  data.tar.gz: 470640b6500e070840f9f03131e0087d2b3fa3ab25d6450dee3d130463f082b8
 SHA512:
-  metadata.gz: 3200e00ca2b898b2ed00c7505ddb005a9ec5bacd5a29fa7c53a89306cbd9264898259e32e46c44ec54d43c618300d54d6324a573ee224aed8005902e82bc55c5
-  data.tar.gz: 56032bf6894c836b70ff22cfdd842b10d180778d362160bbb3156ab3f3a01e8be10c81b60edcfa332a38fb7936c1599ecb8c49285cccee2c0b503a169900edbb
+  metadata.gz: 39453d5478a636f20c45580e91f5a7c9251a0258274e1da16a9736e5b09a74ba7cf4204c65205f44430a35b4a2c7a316a518cd3f5eead7e448723afe747b8e28
+  data.tar.gz: 2b761cbb9ea039c2257e263b46302df7e3c55b4c31849366a5f535141224aa9b1e52a400b75fec88a55486f9cc35a21f96e0d8990a124eb2f0c695e0d873e66c

data/TODO.md

@@ -1,18 +1,29 @@
 # TODO
 
+## 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:
+  ```
+r,w = IO.pipe
+spawn(*%w[echo hello world], out: w)
+spawn(*%w[tr a-z A-Z], in: r)
+```
+
 ## More package managers
 
 Currently missing:
 * RedHat/Fedora/CentOS
 * OSX
-* FreeBSD
+* <s>FreeBSD</s>
 * OpenBSD
 * SuSE
 
-## Abbrev cmds
-
-* eg: upm install => upm i => u i
-
 ## Dependency-fetching features
 
 * Use upm to fetch dependencies for any library or script, across any language.
@@ -37,17 +48,6 @@ Use fzf for "list" output (or other commands that require selecting, like "remov
   * upm install --help
   * upm help install
 
-## 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:
-  ```
-r,w = IO.pipe
-spawn(*%w[echo hello world], out: w)
-spawn(*%w[tr a-z A-Z], in: r)
-```
-
 ## 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?
@@ -88,3 +88,12 @@ 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.6
+0.1.7

data/bin/upm

@@ -4,11 +4,18 @@ $LOAD_PATH.unshift(File.expand_path(File.join('..', 'lib'), bin_dir))
 
 require 'upm'
 
-tool = UPM::Tool.for_os
+unless tool = UPM::Tool.for_os
+  $stderr.puts "Error: I don't recognize this OS, or its package manager."
+  exit 1
+end
+
 command, *args = ARGV
 
 if command.nil?
   tool.help
 else
-  tool.call_command command, *args
+  begin
+    tool.call_command command, *args
+  rescue Interrupt
+  end
 end

data/lib/upm/core_ext.rb

@@ -5,21 +5,38 @@ class DateTime
 end
 
 class File
-  def self.which(bin)
-    ENV["PATH"].split(":").each do |dir|
-      full_path = File.join(dir, bin)
-      return full_path if File.exists? full_path
+
+  #
+  # Overly clever which(), which returns an array if more than one argument was supplied,
+  # or string/nil if only one argument was supplied. 
+  #
+  def self.which(*bins)
+    results = []
+    bins    = bins.flatten
+    paths   = ENV["PATH"].split(":").map { |path| File.realpath(path) rescue nil }.compact.uniq
+
+    paths.each do |dir|
+      bins.each do |bin|
+
+        full_path = File.join(dir, bin)
+        
+        if File.exists?(full_path)
+          if bins.size == 1
+            return full_path
+          else 
+            results << full_path 
+          end
+        end
+
+      end
     end
-    nil
+
+    bins.size == 1 ? nil : results
   end
 
   def self.which_is_best?(*bins)
-    bins.flatten.each do |bin|
-      if location = which(bin)
-        return location
-      end
-    end
-    nil
+    result = which(*bins.flatten)
+    result.is_a?(Array) ? result.first : result
   end
 end
 
@@ -147,4 +164,4 @@ module Enumerable
   end
 
   alias_method :cut_between, :split_between
-end
+end

data/lib/upm/lesspipe.rb

@@ -33,6 +33,16 @@ def lesspipe(*args)
 
   output = args.first if args.any?
 
+  # Don't page, just output to STDOUT
+  if options[:disabled]
+    if output
+      puts output
+    else
+      yield STDOUT
+    end
+    return
+  end
+
   params = []
   params << "-R" unless options[:color] == false
   params << "-S" unless options[:wrap] == true

data/lib/upm/pacman_verifier.rb

@@ -0,0 +1,124 @@
+require 'zlib'
+require 'digest/sha2'
+require 'digest/md5'
+require 'pp'
+
+module UPM
+  class PacmanVerifier
+
+    SKIP_FILES = %w[
+      /.BUILDINFO
+      /.INSTALL
+      /.PKGINFO 
+      /.CHANGELOG
+    ]
+
+    PACKAGE_ROOT = "/var/lib/pacman/local/"
+
+    def compare(key, a, b)
+      a == b ? nil : [key, a, b]
+    end
+
+    def verify!(*included)
+      $stderr.puts "Checking integrity of #{included.any? ? included.size : "installed"} packages..."
+
+      report = []
+
+      Dir.entries(PACKAGE_ROOT).each do |package_dir|
+        mtree_path = File.join(PACKAGE_ROOT, package_dir, "mtree")
+        next unless File.exists?(mtree_path)
+
+        chunks = package_dir.split("-")
+        version = chunks[-2..-1].join("-")
+        package = chunks[0...-2].join("-")
+
+        next unless included.any? and included.include?(package)
+
+        puts "<8>[<7>+<8>] <10>#{package} <3>#{version}".colorize
+
+        result   = []
+        defaults = {}
+
+        Zlib::GzipReader.open(mtree_path) do |io|
+          lines = io.each_line.drop(1)
+         
+          lines.each do |line|
+            path, *expected = line.split
+            expected = expected.map { |opt| opt.split("=") }.to_h
+
+            if path == "/set"
+              defaults = expected
+              next
+            end
+
+            path = path[1..-1] if path[0] == "."
+            path = path.gsub(/\\(\d{3})/) { |m| $1.to_i(8).chr } # unescape \### codes
+
+            # next if expected["type"] == "dir"
+            next if SKIP_FILES.include?(path)
+
+            expected = defaults.merge(expected)
+            lstat    = File.lstat(path)
+
+            errors = expected.map do |key, val|
+              case key
+              when "type"
+                compare("type", lstat.ftype[0...val.size], val)
+              when "link"
+                next if val == "/dev/null"
+                compare("link", File.readlink(path), val)
+              when "gid"
+                compare("gid", lstat.gid, val.to_i)
+              when "uid"
+                compare("uid", lstat.uid, val.to_i)
+              when "mode"
+                compare("mode", "%o" % (lstat.mode & 0xFFF), val)
+              when "size"
+                compare("size", lstat.size, val.to_i)
+              when "time"
+                next if expected["type"] == "dir"
+                next if expected["link"] == "/dev/null"
+                compare("time", lstat.mtime.to_i, val.to_i)
+              when "sha256digest"
+                compare("sha256digest", Digest::SHA256.file(path).hexdigest, val)
+              when "md5digest"
+                next if expected["sha256digest"]
+                compare("md5digest", Digest::MD5.file(path).hexdigest, val)
+              else
+                raise "Unknown key: #{key}=#{val}"
+              end
+            end.compact
+
+            if errors.any?
+              puts "    <4>[<12>*<4>] <11>#{path}".colorize
+              errors.each do |key, a, e| # a=actual, e=expected
+                puts "        <7>expected <14>#{key} <7>to be <2>#{e} <7>but was <4>#{a}".colorize
+                result << [path, "expected #{key.inspect} to be #{e.inspect} but was #{a.inspect}"]
+              end
+            end
+          rescue Errno::EACCES
+            puts "    <1>[<9>!<1>] <11>Can't read <7>#{path} <8>(<9>permission denied<8>)".colorize
+            result << [path, "permission denied"]
+          rescue Errno::ENOENT
+            puts "    <4>[<12>?<4>] <12>Missing file <15>#{path}".colorize
+            result << [path, "missing"]
+          end
+        end # gzip
+
+        report << [package, result] if result.any?
+      end # mtree 
+
+      puts
+      puts "#{report.size} packages with errors (#{report.map { |result| result.size }.sum} errors total)"
+      puts
+
+      if report.any?
+        puts "Packages with problems:"
+        report.each do |package, errors|
+          puts "  #{package} (#{errors.size} errors)"
+        end
+      end
+    end # verify!
+
+  end # PacmanAuditor
+end # UPM

data/lib/upm/tool.rb

@@ -1,3 +1,5 @@
+require 'upm/tool_dsl'
+require 'upm/tool_class_methods'
 
 # os:<pkg> -- automatically select the package manager for the current unix distribution
 # deb:<pkg> (or d: u:)
@@ -10,6 +12,10 @@ module UPM
 
   class Tool
 
+    @@tools = {}
+
+    include UPM::Tool::DSL
+
     COMMAND_HELP = {
       "install"          => "install a package",
       "remove/uninstall" => "remove a package",
@@ -18,17 +24,20 @@ module UPM
       "list"             => "list installed packages (or search their names if extra arguments are supplied)",
       "info"             => "show metadata about a package",
       "update/sync"      => "retrieve the latest package list or manifest",
-      "upgrade"          => "install new versions of all packages",
+      "upgrade"          => "update package list and install updates",
+      "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",
       "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",
-      "verfiy"           => "verify the integrity of installed files",
       "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)",
     }
 
     ALIASES = {
@@ -36,58 +45,17 @@ module UPM
       "sync"    => "update",
       "sources" => "mirrors",
       "show"    => "info",
+      "vuln"    => "audit",
+      "vulns"   => "audit",
+      "check"   => "verify",
+      "u"       => "upgrade",
+      "i"       => "install",
+      "d"       => "download",
+      "s"       => "search",
+      "f"       => "files",
+      "r"       => "remove",
     }
 
-    @@tools = {}
-    def self.tools; @@tools; end
-
-    def self.register_tools!
-      Dir["#{__dir__}/tools/*.rb"].each { |lib| require_relative(lib) }
-    end
-
-    def self.os_release
-      @os_release ||= begin
-        open("/etc/os-release") do |io|
-          io.read.scan(/^(\w+)="?(.+?)"?$/)
-        end.to_h
-      rescue Errno::ENOENT
-        {}
-      end
-    end
-
-    def self.current_os_names
-      # ID=ubuntu
-      # ID_LIKE=debian
-      os_release.values_at("ID", "ID_LIKE").compact
-    end
-
-    def self.nice_os_name
-      os_release.values_at("PRETTY_NAME", "NAME", "ID", "ID_LIKE").first || 
-        (`uname -o`.chomp rescue nil)
-    end
-
-    def self.for_os(os_names=nil)
-      os_names = os_names ? [os_names].flatten : current_os_names
-
-      tool = nil
-
-      if os_names.any?
-        tool = @@tools.find { |name, tool| os_names.any? { |name| tool.os.include? name } }.last
-      end
-
-      if tool.nil?
-        tool = @@tools.find { |name, tool| File.which(tool.identifying_binary) }.last
-      end
-
-      if tool.nil?
-        puts "Error: couldn't find a package manager."
-      end
-
-      tool
-    end
-
-    ###################################################################
-
     def initialize(name, &block)
       @name = name
       instance_eval(&block)
@@ -95,117 +63,6 @@ module UPM
       @@tools[name] = self
     end
 
-    def call_command(name, *args)
-      if block = (@cmds[name] || @cmds[ALIASES[name]])
-        block.call args
-      else
-        puts "Command #{name} not supported in #{@name}"
-      end
-    end
-
-    def help
-      if osname = Tool.nice_os_name
-        puts "    Detected OS: #{osname}"
-      end
-
-      puts "Package manager: #{@name}"
-      puts
-      puts "Available commands:"
-      available = COMMAND_HELP.select do |name, desc|
-        names = name.split("/")
-        names.any? { |name| @cmds[name] }
-      end
-
-      max_width = available.map(&:first).map(&:size).max
-      available.each do |name, desc|
-        puts "  #{name.rjust(max_width)} | #{desc}"
-      end
-    end
-
-    ## DSL methods
-
-    def identifying_binary(id_bin=nil)
-      if id_bin 
-        @id_bin = id_bin
-      else
-        @id_bin || @name
-      end
-    end
-
-    def prefix(name)
-      @prefix = name
-    end
-
-    def command(name, shell_command=nil, root: false, paged: false, &block)
-      @cmds ||= {}
-
-      if block_given?
-        @cmds[name] = block
-      elsif shell_command
-        if shell_command.is_a? String
-          shell_command = shell_command.split
-        elsif not shell_command.is_a? Array
-          raise "Error: command argument must be a String or an Array; it was a #{cmd.class}"
-        end
-
-        @cmds[name] = proc { |args| run(*shell_command, *args, paged: paged, root: root) }
-      end
-    end
-
-    def os(*names)
-      names.any? ? @os = names : @os
-    end
-
-    ## Helpers
-
-    def run(*args, root: false, paged: false, grep: nil)
-      if root and File.which("sudo") 
-        args.unshift "sudo" 
-      end
-
-      if !paged and !grep
-        system(*args)
-      else
-
-        IO.popen(args, err: [:child, :out]) do |command_io|
-          
-          if grep
-            pattern = grep.is_a?(Regexp) ? grep.source : grep.to_s 
-            grep_io = IO.popen(["grep", "--color=always", "-Ei", pattern], "w+")
-            IO.copy_stream(command_io, grep_io)
-            grep_io.close_write
-            command_io = grep_io
-          end
-
-          if paged
-            lesspipe do |less|
-              IO.copy_stream(command_io, less)
-            end
-          else
-            IO.copy_stream(command_io, STDOUT)
-          end
-
-        end
-
-        $?.to_i == 0
-      end
-    end
-
-    def print_files(*paths, include: nil, exclude: nil)
-      lesspipe do |less|
-        paths.each do |path|
-          less.puts "<8>=== <11>#{path} <8>========".colorize
-          open(path) do |io|
-            enum = io.each_line
-            enum = enum.grep(include) if include
-            enum = enum.reject { |line| line[exclude] } if exclude
-            enum.each { |line| less.puts line }
-          end
-          less.puts
-        end
-      end
-    end
-
   end # class Tool
 
 end # module UPM

data/lib/upm/tool_class_methods.rb

@@ -0,0 +1,59 @@
+module UPM
+  class Tool
+    class << self
+
+      def tools; @@tools; end
+
+      def register_tools!
+        Dir["#{__dir__}/tools/*.rb"].each { |lib| require_relative(lib) }
+      end
+
+      def os_release
+        @os_release ||= begin
+          open("/etc/os-release") do |io|
+            io.read.scan(/^(\w+)="?(.+?)"?$/)
+          end.to_h
+        rescue Errno::ENOENT
+          {}
+        end
+      end
+
+      def current_os_names
+        # eg: ID=ubuntu, ID_LIKE=debian
+        if os_release
+          os_release.values_at("ID", "ID_LIKE").compact
+        else
+          # `uname -s` => Darwin|FreeBSD|OpenBSD
+          # `uname -o` => Android|Cygwin
+          [`uname -s`, `uname -o`].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)
+      end
+
+      def installed
+        @@tools.select { |tool| File.which(tool.identifying_binary) }
+      end
+
+      def for_os(os_names=nil)
+        os_names = os_names ? [os_names].flatten : current_os_names
+
+        tool = nil
+
+        if os_names.any?
+          tool = @@tools.find { |name, tool| os_names.any? { |name| tool.os.include? name } }&.last
+        end
+
+        if tool.nil?
+          tool = @@tools.find { |name, tool| File.which(tool.identifying_binary) }&.last
+        end
+
+        tool
+      end
+
+    end
+  end
+end

data/lib/upm/tool_dsl.rb

@@ -0,0 +1,144 @@
+module UPM
+  class Tool
+    module DSL
+      def identifying_binary(id_bin=nil)
+        if id_bin 
+          @id_bin = id_bin
+        else
+          @id_bin || @name
+        end
+      end
+
+      def prefix(name)
+        @prefix = name
+      end
+
+      def command(name, shell_command=nil, root: false, paged: false, highlight: nil, &block)
+        @cmds ||= {}
+
+        if block_given?
+          @cmds[name] = block
+        elsif shell_command
+          if shell_command.is_a? String
+            shell_command = shell_command.split
+          elsif not shell_command.is_a? Array
+            raise "Error: command argument must be a String or an Array; it was a #{cmd.class}"
+          end
+
+          @cmds[name] = proc do |args|
+            query = highlight && args.join(" ") 
+            run(*shell_command, *args, paged: paged, root: root, highlight: query)
+          end
+        end
+      end
+
+      def os(*names)
+        names.any? ? @os = names : @os
+      end
+
+      ## Helpers
+
+      def run(*args, root: false, paged: false, grep: nil, highlight: nil)
+        if root
+          if Process.uid != 0
+            if File.which("sudo") 
+              args.unshift "sudo"
+            elsif File.which("su")
+              args = ["su", "-c"] + args
+            else
+              raise "Error: You must be root to run this command. (And I couldn't find the 'sudo' *or* 'su' commands.)"
+            end
+          end   
+        end
+
+        if !paged and !grep
+          system(*args)
+        else
+
+          IO.popen(args, err: [:child, :out]) do |command_io|
+            
+            # if grep
+            #   pattern = grep.is_a?(Regexp) ? grep.source : grep.to_s 
+            #   grep_io = IO.popen(["grep", "--color=always", "-Ei", pattern], "w+")
+            #   IO.copy_stream(command_io, grep_io)
+            #   grep_io.close_write
+            #   command_io = grep_io
+            # end
+
+            # if paged
+            #   lesspipe do |less|
+            #     IO.copy_stream(command_io, less)
+            #   end
+            # else
+            #   IO.copy_stream(command_io, STDOUT)
+            # end
+
+            highlight_proc = if highlight
+              proc { |line| line.gsub(highlight) { |m| "\e[33;1m#{m}\e[0m" } }
+            else
+              proc { |line| line }
+            end
+
+            grep_proc = if grep
+              proc { |line| line[grep] }
+            else
+              proc { true }
+            end
+
+            lesspipe(disabled: !paged) do |less|
+              command_io.each_line do |line|
+                less.puts highlight_proc.(line) if grep_proc.(line)
+              end
+            end
+
+          end
+
+          $?.to_i == 0
+        end
+      end
+
+      def print_files(*paths, include: nil, exclude: nil)
+        lesspipe do |less|
+          paths.each do |path|
+            less.puts "<8>=== <11>#{path} <8>========".colorize
+            open(path) do |io|
+              enum = io.each_line
+              enum = enum.grep(include) if include
+              enum = enum.reject { |line| line[exclude] } if exclude
+              enum.each { |line| less.puts line }
+            end
+            less.puts
+          end
+        end
+      end
+
+      def call_command(name, *args)
+        if block = (@cmds[name] || @cmds[ALIASES[name]])
+          block.call args
+        else
+          puts "Command #{name} not supported in #{@name}"
+        end
+      end
+
+      def help
+        if osname = Tool.nice_os_name
+          puts "    Detected OS: #{osname}"
+        end
+
+        puts "Package manager: #{@name}"
+        puts
+        puts "Available commands:"
+        available = COMMAND_HELP.select do |name, desc|
+          names = name.split("/")
+          names.any? { |name| @cmds[name] }
+        end
+
+        max_width = available.map(&:first).map(&:size).max
+        available.each do |name, desc|
+          puts "  #{name.rjust(max_width)} | #{desc}"
+        end
+      end
+
+    end # DSL
+  end # Tool
+end # UPM

data/lib/upm/tools/pacman.rb

@@ -1,3 +1,4 @@
+
 UPM::Tool.new "pacman" do
 
   os "arch"
@@ -9,17 +10,25 @@ UPM::Tool.new "pacman" do
   command "upgrade", [*bin, "-Syu"], root: true
   command "remove",  [*bin, "-R"],   root: true
 
+  # command "check",  [*bin, "-Qkk"]
+  command "verify" do |args|
+    require 'upm/pacman_verifier'
+    UPM::PacmanVerifier.new.verify!(*args)
+  end
+
+  command "audit",  "arch-audit",  paged: true
   command "files",  [*bin, "-Ql"], paged: true
   command "search", [*bin, "-Ss"], paged: true
 
+
   command "info" do |args|
-    run(*bin, "-Qi", *args) || run(*bin, "-Si", *args)
+    run(*bin, "-Qi", *args, paged: true) || run(*bin, "-Si", *args, paged: true)
   end
 
   command "list" do |args|
     if args.any?
       query = args.join
-      run(*bin, "-Q", grep: query, paged: true)
+      run(*bin, "-Q", grep: query, highlight: query, paged: true)
     else
       run(*bin, "-Q", paged: true)
     end

data/lib/upm/tools/pkg.rb

@@ -0,0 +1,24 @@
+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 "check",   "pkg check --checksums", root: true
+
+  command "files",   "pkg list",    paged: true
+  command "search",  "pkg search",  paged: true, highlight: true
+  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
+
+end

data/lib/upm/tools/xbps.rb

@@ -4,18 +4,19 @@ 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 "files",   "xbps-query -f"
-  command "search",  "xbps-query --regex -Rs"
-  # command "info", ""
+  command "install", "xbps-install",      root: true
+  command "update",  "xbps-install -S",   root: true
+  command "upgrade", "xbps-install -Su",  root: true
+
+  command "files",   "xbps-query -f",           paged: true
+  command "search",  "xbps-query --regex -Rs",  paged: true
   
   command "list" do |args|
     if args.any?
-      run "xbps-query", "-f", *args
+      query = args.join
+      run "xbps-query", "-l", grep: query, paged: true
     else
-      run "xbps-query", "-l"
+      run "xbps-query", "-l", paged: true
     end
   end
 

data/spec/core_ext_spec.rb

@@ -0,0 +1,18 @@
+require_relative "spec_helper"
+require "upm/core_ext"
+
+describe File do
+
+  it "whiches" do
+    File.which("ls").should == "/usr/bin/ls"
+    File.which("ls", "rm").should == ["/usr/bin/ls", "/usr/bin/rm"]
+    File.which("zzzzzzzzzzzzzzzzzzzzzzzzzzzz").should == nil
+  end
+
+  it "which_is_best?s" do
+    File.which_is_best?("ls", "rm", "sudo").should == "/usr/bin/ls"
+    File.which_is_best?("sudo").should == "/usr/bin/sudo"
+    File.which_is_best?("zzzzzzzzzzzzzzzzzz").should == nil
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+$:.unshift File.join(__dir__, "../lib")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: upm
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - epitron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-04 00:00:00.000000000 Z
+date: 2018-05-19 00:00:00.000000000 Z
 dependencies: []
 description: Wrap all known command-line package tools with a consistent and pretty
   interface.
@@ -33,10 +33,16 @@ files:
 - lib/upm/core_ext.rb
 - lib/upm/lesspipe.rb
 - lib/upm/log_parser.rb
+- lib/upm/pacman_verifier.rb
 - lib/upm/tool.rb
+- lib/upm/tool_class_methods.rb
+- lib/upm/tool_dsl.rb
 - lib/upm/tools/apt.rb
 - lib/upm/tools/pacman.rb
+- lib/upm/tools/pkg.rb
 - lib/upm/tools/xbps.rb
+- spec/core_ext_spec.rb
+- spec/spec_helper.rb
 homepage: http://github.com/epitron/upm/
 licenses:
 - WTFPL