upm 0.0.0 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 60027059fa9203a42da7e7fddd3fafc34f889d49
-  data.tar.gz: 4b37928fe24f4eeb3336fbd70eb74ec02c58e110
+SHA256:
+  metadata.gz: 4da92ce63688e75043c91e8d40bf9a1829687b974a4bc21bc40e23c06ce108f9
+  data.tar.gz: 0eb4815df308f4dfaffdcc9fee5a877c65dda0d65f85ed3149fdb338bc34517b
 SHA512:
-  metadata.gz: 875dfba6634cd5121ea32b22342b7a8b659d56668c0bb0c23b5e08d128ef09b6bc44e7df1eff73dbaffcdd5cc4db739501364d5471382606367da09dbe3c144d
-  data.tar.gz: 4c56742fd0d34c5ab7201a17691f1f02f98aa7f48f1a4e5ec35ae11ae27c765a7a3350ea2a9b3225137e32a4309fc46ba38c6d43391048aae50896af821fab44
+  metadata.gz: d8ca05eff0cd5037aa9a30b9206d79933fdd7fe6bc8a7d225185278c0696965416ba5d0315fec9cc25a1ecb1ed566ed80704b213c9fee1e37b515596a1d50dc0
+  data.tar.gz: 7a0341ee388207404b5a785d7d27fd5a563f886a8638165539f1a790520e9c097b8d33bbbd2f79d046183a6515e73d5d1cb08ab44f0e3a0d33fb7d4e58f6df94

data/.gemspec

@@ -2,26 +2,17 @@
 # -*- coding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name = "upm"
-
-  s.version = File.read "VERSION"
-  s.date = File.mtime("VERSION").strftime("%Y-%m-%d")
-
-  s.summary = "Universal Package Manager"
+  s.name        = "upm"
+  s.version     = File.read "VERSION"
+  s.date        = File.mtime("VERSION").strftime("%Y-%m-%d")
+  s.summary     = "Universal Package Manager"
   s.description = "Wrap all known command-line package tools with a consistent and pretty interface."
-
-  s.homepage = "http://github.com/epitron/upm/"
-  s.licenses = ["WTFPL"]
-
-  s.email   = "chris@ill-logic.com"
-  s.authors = ["epitron"]
-
-  # s.executables = ["upm", "up", "u"]
+  s.homepage    = "http://github.com/epitron/upm/"
+  s.licenses    = ["WTFPL"]
+  s.email       = "chris@ill-logic.com"
+  s.authors     = ["epitron"]
+  s.executables = ["upm"]
 
   s.files = `git ls`.lines.map(&:strip)
   s.extra_rdoc_files = ["README.md", "LICENSE"]
-
-  # s.require_paths = %w[lib]
-
-  # s.add_dependency "slop", "~> 3.0"
 end

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/README.md

@@ -1,5 +1,11 @@
 # upm: Universal Package Manager
 
+## 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.
+
+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.
+
 ## Usage:
 
 ```
@@ -8,35 +14,36 @@ up <command> <pkg>
 u <command> <pkg>
 ```
 
-## Commands
-
-* list
-* search
-* install
-* sync/update
-* upgrade
-* log - show history of package installs 
-* pin
-* rollback
-* packagers - detect package systems, and enable/disable them
-* sources/mirrors - select remote repositories and mirrors
-* verfiy - verifies integrity of installed packages
-* remove
-* clean
-* build
-* monitor - ad-hoc package manager for custom installations (like instmon)
-* keys - keyrings and package authentication
-* default - configurable default action (defaults to update only the OS)
-
-### All searches and package names can be prefixed with their namespace:
+## Commands:
+
+* `install`
+* `remove`
+* `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
+* `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 
+* `packagers` - detect installed package managers, and pick which ones upm should wrap
+* `sources`/`mirrors` - select remote repositories and mirrors
+* `verfiy` - verifies 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")
+
+### Any command that takes a package name can be prefixed with the package tool's namespace:
 
 ```
-ruby:<pkg> (or r:)
-deb:<pkg> (or d:)
-rpm:<pkg>
-python:<pkg>
-py:<pkg>
-pip:<pkg>
+os:<pkg> -- automatically select the package manager for the current unix distribution
+deb:<pkg> (or d: u:)
+rpm:<pkg> (or yum: y:)
+bsd:<pkg> (or b:)
+ruby:<pkg> (or r: gem:)
+python:<pkg>,<pkg> (or py: p: pip:)
 ```
 
 ### ...or suffixed with its file extension:
@@ -48,25 +55,52 @@ pip:<pkg>
 <pkg>.pip
 ```
 
-## Supported packagers:
+## Package tools to wrap:
+
+* Arch: `pacman`/`aur`/`abs` (svn mirror)
+* Debian/Ubuntu: `apt-get`/`dpkg` (+ curated list of ppa's)
+* RedHat/Fedora/Centos: `yum`/`rpm`
+* Mac OSX: `brew`/`fink`/`ports`
+* FreeBSD: `pkg`/`ports`
+* OpenBSD: `pkg_add`/`ports`
+* NetBSD: `pkgin`/`ports`
+* SmartOS/Illumos: `pkgin`
+* Windows: `apt-cyg`/`mingw-get`/`nuget`/`Windows Update`/(as-yet-not-created package manager, "winget")
+* Wine: `winetricks`
+* Ruby: `rubygems`
+* Python: `pip`/`easy_install`
+* Javascript: `npm`
+* Clojure: `leiningen`
+* Java: `gradle`
+* Erlang: `rebar`
+* Scala: `sbt`
+* Rust: `cargo`
+* R: `cran`
+* Lua: `rocks`
+* Julia: `Pkg`
+* Haskell: `cabal`
+* Perl: `cpan`
+* go: `go-get`
+
+...[and many more!](https://en.wikipedia.org/wiki/List_of_software_package_management_systems)
+
+
+## What it might look like:
+
+Info:
+
+![acs](https://raw.githubusercontent.com/epitron/scripts/master/screenshots/acs.png)
+
+Log:
+
+![paclog](https://raw.githubusercontent.com/epitron/scripts/master/screenshots/paclog.png)
 
-* OpenBSD: pkg_add
-* FreeBSD: pkg
-* RedHat/Fedora/Centos: yum/rpm
-* Debian/Ubuntu: apt-get/dpkg (+ curated list of ppa's)
-* Windows: apt-cyg/nuget/"winget" (new package manager)
-* Arch: pacman/aur/abs (svn mirror)
-* Mac OSX: brew/fink
-* Python: pip/easy_install
-* Ruby: rubygems
-* Haskell: cabal
-* Perl: cpan
-* go: go-get
-* Java: ?
+Rollback:
 
+![pacman-rollback](https://raw.githubusercontent.com/epitron/scripts/master/screenshots/pacman-rollback.png)
 
 ## TODOs:
 
-* Build using the pretty text-mode UI that passenger-install uses
+* Use the pretty text-mode UI that passenger-install uses
 * Context-dependent operation
-  * if you're in a ruby project, prioritize the 'ruby' namespace
+  * eg: if you're in a ruby project's directory, set the 'ruby' namespace to highest priority

data/Rakefile

@@ -9,7 +9,7 @@ task :release => :build do
   system "gem push #{pkgname}-#{gem_version}.gem"
 end
 
-task :gem => :release
+task :gem => :build
 
 task :install => :build do
   system "gem install #{pkgname}-#{gem_version}.gem"

data/TODO.md

@@ -0,0 +1,38 @@
+# TODO
+
+## More package managers
+
+Currently missing:
+* RedHat/Fedora/CentOS
+* OSX
+* FreeBSD
+* OpenBSD
+* SuSE
+
+## fzf
+
+Use fzf for "list" output (or other commands that require selecting, like "remove")
+
+## Proper ARGV parser
+
+* Something better than "command, *args = ARGV" (with "--help" available, at the very least.)
+
+## Streaming pipes
+
+* 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`.
+
+## 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: 
+    * upm install --ruby <pkg>
+    * upm install ruby:<pkg>,<pkg>
+* Add detectors for language-specific package-managers
+* Help screen needs to display language-specific package managers
+* `upm help --ruby` should show available ruby commands
+
+## Mirror Selector
+
+* Do a ping test on available mirrors, and use fzf to select

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.1.0

data/bin/upm

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+bin_dir = File.dirname(File.realpath(__FILE__))
+$LOAD_PATH.unshift(File.expand_path(File.join('..', 'lib'), bin_dir))
+
+require 'upm'
+
+tool = UPM::Tool.for_os
+command, *args = ARGV
+
+if command.nil?
+  tool.help
+else
+  tool.call_command command, args
+end

data/lib/upm/colored.rb

@@ -0,0 +1,320 @@
+#
+# ANSI Colour-coding (for terminals that support it.)
+#
+# Originally by defunkt (Chris Wanstrath)
+#   Enhanced by epitron (Chris Gahan)
+#
+# It adds methods to String to allow easy coloring.
+#
+# (Note: Colors are automatically disabled if your program is piped to another program,
+#        ie: if STDOUT is not a TTY)
+#
+# Basic examples:
+#
+#   >> "this is red".red
+#   >> "this is red with a blue background (read: ugly)".red_on_blue
+#   >> "this is light blue".light_blue
+#   >> "this is red with an underline".red.underline
+#   >> "this is really bold and really blue".bold.blue
+#
+# Color tags:
+# (Note: You don't *need* to close color tags, but you can!)
+#
+#   >> "<yellow>This is using <green>color tags</green> to colorize.".colorize
+#   >> "<1>N<9>u<11>m<15>eric tags!".colorize
+#   (For those who still remember the DOS color palette and want more terse tagged-colors.)
+#
+# Highlight search results:
+#
+#   >> string.gsub(pattern) { |match| "<yellow>#{match}</yellow>" }.colorize
+#
+# Forcing colors:
+#
+# Since the presence of a terminal is detected automatically, the colors will be
+# disabled when you pipe your program to another program. However, if you want to
+# show colors when piped (eg: when you pipe to `less -R`), you can force it:
+#
+#   >> Colored.enable!
+#   >> Colored.disable!
+#   >> Colored.enable_temporarily { puts "whee!".red }
+#
+
+require 'set'
+require 'rbconfig'
+require 'Win32/Console/ANSI' if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+#require 'Win32/Console/ANSI' if RUBY_PLATFORM =~ /win32/
+
+module Colored
+  extend self
+
+  @@is_tty = STDOUT.isatty
+
+  COLORS = {
+    'black'   => 30,
+    'red'     => 31,
+    'green'   => 32,
+    'yellow'  => 33,
+    'blue'    => 34,
+    'magenta' => 35,
+    'purple'  => 35,
+    'cyan'    => 36,
+    'white'   => 37
+  }
+
+  EXTRAS = {
+    'clear'     => 0,
+    'bold'      => 1,
+    'light'     => 1,
+    'underline' => 4,
+    'reversed'  => 7
+  }
+
+  #
+  # BBS-style numeric color codes.
+  #
+  BBS_COLOR_TABLE = {
+    0   => :black,
+    1   => :blue,
+    2   => :green,
+    3   => :cyan,
+    4   => :red,
+    5   => :magenta,
+    6   => :yellow,
+    7   => :white,
+    8   => :light_black,
+    9   => :light_blue,
+    10  => :light_green,
+    11  => :light_cyan,
+    12  => :light_red,
+    13  => :light_magenta,
+    14  => :light_yellow,
+    15  => :light_white,
+  }
+
+  VALID_COLORS = begin
+    normal         = COLORS.keys
+    lights         = normal.map { |fore| "light_#{fore}" }
+    brights        = normal.map { |fore| "bright_#{fore}" }
+    on_backgrounds = normal.map { |fore| normal.map { |back| "#{fore}_on_#{back}" } }.flatten
+
+    Set.new(normal + lights + brights + on_backgrounds + ["grey", "gray"])
+  end
+
+  COLORS.each do |color, value|
+    define_method(color) do
+      colorize(self, :foreground => color)
+    end
+
+    define_method("on_#{color}") do
+      colorize(self, :background => color)
+    end
+
+    define_method("light_#{color}") do
+      colorize(self, :foreground => color, :extra => 'bold')
+    end
+
+    define_method("bright_#{color}") do
+      colorize(self, :foreground => color, :extra => 'bold')
+    end
+
+    COLORS.each do |highlight, value|
+      next if color == highlight
+
+      define_method("#{color}_on_#{highlight}") do
+        colorize(self, :foreground => color, :background => highlight)
+      end
+
+      define_method("light_#{color}_on_#{highlight}") do
+        colorize(self, :foreground => color, :background => highlight, :extra => 'bold')
+      end
+
+    end
+  end
+
+  alias_method :gray, :light_black
+  alias_method :grey, :light_black
+
+  EXTRAS.each do |extra, value|
+    next if extra == 'clear'
+    define_method(extra) do
+      colorize(self, :extra => extra)
+    end
+  end
+
+  define_method(:to_eol) do
+    tmp = sub(/^(\e\[[\[\e0-9;m]+m)/, "\\1\e[2K")
+    if tmp == self
+      return "\e[2K" << self
+    end
+    tmp
+  end
+
+  #
+  # Colorize a string (this method is called by #red, #blue, #red_on_green, etc.)
+  #
+  # Accepts options:
+  #   :foreground
+  #       The name of the foreground color as a string.
+  #   :background
+  #       The name of the background color as a string.
+  #   :extra
+  #       Extra styling, like 'bold', 'light', 'underline', 'reversed', or 'clear'.
+  #
+  #
+  # With no options, it uses tagged colors:
+  #
+  #    puts "<light_green><magenta>*</magenta> Hey mom! I am <light_blue>SO</light_blue> colored right now.</light_green>".colorize
+  #
+  # Or numeric ANSI tagged colors (from the BBS days):
+  #    puts "<10><5>*</5> Hey mom! I am <9>SO</9> colored right now.</10>".colorize
+  #
+  #
+  def colorize(string=nil, options = {})
+    if string == nil
+      return self.tagged_colors
+    end
+
+    if @@is_tty
+      colored = [color(options[:foreground]), color("on_#{options[:background]}"), extra(options[:extra])].compact * ''
+      colored << string
+      colored << extra(:clear)
+    else
+      string
+    end
+  end
+
+  #
+  # Find all occurrences of "pattern" in the string and highlight them
+  # with the specified color. (defaults to light_yellow)
+  #
+  # The pattern can be a string or a regular expression.
+  #
+  def highlight(pattern, color=:light_yellow, &block)
+    pattern = Regexp.new(Regexp.escape(pattern)) if pattern.is_a? String
+
+    if block_given?
+      gsub(pattern, &block)
+    else
+      gsub(pattern) { |match| match.send(color) }
+    end
+  end
+
+  #
+  # An array of all possible colors.
+  #
+  def colors
+    @@colors ||= COLORS.keys.sort
+  end
+
+  #
+  # Returns the terminal code for one of the extra styling options.
+  #
+  def extra(extra_name)
+    extra_name = extra_name.to_s
+    "\e[#{EXTRAS[extra_name]}m" if EXTRAS[extra_name]
+  end
+
+  #
+  # Returns the terminal code for a specified color.
+  #
+  def color(color_name)
+    background = color_name.to_s =~ /on_/
+    color_name = color_name.to_s.sub('on_', '')
+    return unless color_name && COLORS[color_name]
+    "\e[#{COLORS[color_name] + (background ? 10 : 0)}m"
+  end
+
+  #
+  # Will color commands actually modify the strings?
+  #
+  def enabled?
+    @@is_tty
+  end
+
+  alias_method :is_tty?, :enabled?
+
+  #
+  # Color commands will always produce colored strings, regardless
+  # of whether the script is being run in a terminal.
+  #
+  def enable!
+    @@is_tty = true
+  end
+
+  alias_method :force!, :enable!
+
+  #
+  # Enable Colored just for this block.
+  #
+  def enable_temporarily(&block)
+    last_state = @@is_tty
+
+    @@is_tty = true
+    block.call
+    @@is_tty = last_state
+  end
+
+  #
+  # Color commands will do nothing.
+  #
+  def disable!
+    @@is_tty = false
+  end
+
+  #
+  # Is this string legal?
+  #
+  def valid_tag?(tag)
+    VALID_COLORS.include?(tag) or
+      (tag =~ /^\d+$/ and BBS_COLOR_TABLE.include?(tag.to_i) )
+  end
+
+  #
+  # Colorize a string that has "color tags".
+  #
+  def tagged_colors
+    stack = []
+
+    # split the string into tags and literal strings
+    tokens          = self.split(/(<\/?[\w\d_]+>)/)
+    tokens.delete_if { |token| token.size == 0 }
+
+    result        = ""
+
+    tokens.each do |token|
+
+      # token is an opening tag!
+
+      if /<([\w\d_]+)>/ =~ token and valid_tag?($1)
+        stack.push $1
+
+      # token is a closing tag!
+
+      elsif /<\/([\w\d_]+)>/ =~ token and valid_tag?($1)
+
+        # if this color is on the stack somwehere...
+        if pos = stack.rindex($1)
+          # close the tag by removing it from the stack
+          stack.delete_at pos
+        else
+          raise "Error: tried to close an unopened color tag -- #{token}"
+        end
+
+      # token is a literal string!
+
+      else
+
+        color = (stack.last || "white")
+        color = BBS_COLOR_TABLE[color.to_i] if color =~ /^\d+$/
+        result << token.send(color)
+
+      end
+
+    end
+
+    result
+  end
+
+end unless Object.const_defined? :Colored
+
+String.send(:include, Colored)

data/lib/upm/core_ext.rb

@@ -0,0 +1,131 @@
+require 'date'
+
+class DateTime
+  def to_i; to_time.to_i; end
+end
+
+module Enumerable
+  #
+  # Split this enumerable into chunks, given some boundary condition. (Returns an array of arrays.)
+  #
+  # Options:
+  #   :include_boundary => true  #=> include the element that you're splitting at in the results
+  #                                  (default: false)
+  #   :after => true             #=> split after the matched element (only has an effect when used with :include_boundary)
+  #                                  (default: false)
+  #   :once => flase             #=> only perform one split (default: false)
+  #
+  # Examples:
+  #   [1,2,3,4,5].split{ |e| e == 3 }
+  #   #=> [ [1,2], [4,5] ]
+  #
+  #   "hello\n\nthere\n".each_line.split_at("\n").to_a
+  #   #=> [ ["hello\n"], ["there\n"] ]
+  #
+  #   [1,2,3,4,5].split(:include_boundary=>true) { |e| e == 3 }
+  #   #=> [ [1,2], [3,4,5] ]
+  #
+  #   chapters = File.read("ebook.txt").split(/Chapter \d+/, :include_boundary=>true)
+  #   #=> [ ["Chapter 1", ...], ["Chapter 2", ...], etc. ]
+  #
+  def split_at(matcher=nil, options={}, &block)
+    include_boundary = options[:include_boundary] || false
+
+    if matcher.nil?
+      boundary_test_proc = block
+    else
+      if matcher.is_a? Regexp
+        boundary_test_proc = proc { |element| element =~ matcher }
+      else
+        boundary_test_proc = proc { |element| element == matcher }
+      end
+    end
+
+    Enumerator.new do |yielder|
+      current_chunk = []
+      splits        = 0
+      max_splits    = options[:once] == true ? 1 : options[:max_splits]
+
+      each do |e|
+
+        if boundary_test_proc.call(e) and (max_splits == nil or splits < max_splits)
+
+          if current_chunk.empty? and not include_boundary
+            next # hit 2 boundaries in a row... just keep moving, people!
+          end
+
+          if options[:after]
+            # split after boundary
+            current_chunk << e        if include_boundary   # include the boundary, if necessary
+            yielder << current_chunk                         # shift everything after the boundary into the resultset
+            current_chunk = []                              # start a new result
+          else
+            # split before boundary
+            yielder << current_chunk                         # shift before the boundary into the resultset
+            current_chunk = []                              # start a new result
+            current_chunk << e        if include_boundary   # include the boundary, if necessary
+          end
+
+          splits += 1
+
+        else
+          current_chunk << e
+        end
+
+      end
+
+      yielder << current_chunk if current_chunk.any?
+
+    end
+  end
+
+  #
+  # Split the array into chunks, cutting between the matched element and the next element.
+  #
+  # Example:
+  #   [1,2,3,4].split_after{|e| e == 3 } #=> [ [1,2,3], [4] ]
+  #
+  def split_after(matcher=nil, options={}, &block)
+    options[:after]             ||= true
+    options[:include_boundary]  ||= true
+    split_at(matcher, options, &block)
+  end
+
+  #
+  # Split the array into chunks, cutting before each matched element.
+  #
+  # Example:
+  #   [1,2,3,4].split_before{|e| e == 3 } #=> [ [1,2], [3,4] ]
+  #
+  def split_before(matcher=nil, options={}, &block)
+    options[:include_boundary]  ||= true
+    split_at(matcher, options, &block)
+  end
+
+  #
+  # Split the array into chunks, cutting between two elements.
+  #
+  # Example:
+  #   [1,1,2,2].split_between{|a,b| a != b } #=> [ [1,1], [2,2] ]
+  #
+  def split_between(&block)
+    Enumerator.new do |yielder|
+      current = []
+      last    = nil
+
+      each_cons(2) do |a,b|
+        current << a
+        if yield(a,b)
+          yielder << current
+          current = []
+        end
+        last = b
+      end
+
+      current << last unless last.nil?
+      yielder << current
+    end
+  end
+
+  alias_method :cut_between, :split_between
+end

data/lib/upm/lesspipe.rb

@@ -0,0 +1,57 @@
+#
+# Create scrollable output via less!
+#
+# This command runs `less` in a subprocess, and gives you the IO to its STDIN pipe
+# so that you can communicate with it.
+#
+# Example:
+#
+#   lesspipe do |less|
+#     50.times { less.puts "Hi mom!" }
+#   end
+#
+# The default less parameters are:
+# * Allow colour
+# * Don't wrap lines longer than the screen
+# * Quit immediately (without paging) if there's less than one screen of text.
+#
+# You can change these options by passing a hash to `lesspipe`, like so:
+#
+#   lesspipe(:wrap=>false) { |less| less.puts essay.to_s }
+#
+# It accepts the following boolean options:
+#    :color  => Allow ANSI colour codes?
+#    :wrap   => Wrap long lines?
+#    :always => Always page, even if there's less than one page of text?
+#
+def lesspipe(*args)
+  if args.any? and args.last.is_a?(Hash)
+    options = args.pop
+  else
+    options = {}
+  end
+
+  output = args.first if args.any?
+
+  params = []
+  params << "-R" unless options[:color] == false
+  params << "-S" unless options[:wrap] == true
+  params << "-F" unless options[:always] == true
+  if options[:tail] == true
+    params << "+\\>"
+    $stderr.puts "Seeking to end of stream..."
+  end
+  params << "-X"
+
+  IO.popen("less #{params * ' '}", "w") do |less|
+    if output
+      less.puts output
+    else
+      yield less
+    end
+  end
+
+rescue Errno::EPIPE, Interrupt
+  # less just quit -- eat the exception.
+end
+

data/lib/upm/log_parser.rb

@@ -0,0 +1,56 @@
+module UPM
+  class LogParser
+
+    def initialize(klass, log_glob)
+      @klass = klass
+      @log_glob = log_glob
+    end
+
+    def log_events
+      return to_enum(:log_events) unless block_given?
+
+      yielder = proc do |io|
+        io.each_line do |line|
+          if e = @klass.from_line(line.strip)
+            yield e
+          end
+        end
+      end
+
+      logs = Dir[@log_glob].sort_by { |path| File.mtime(path) } 
+
+      logs.each do |log|
+        if log =~ /\.gz$/
+          IO.popen(["zcat", log], &yielder)
+        else
+          open(log, &yielder)
+        end 
+      end
+    end
+
+    def display
+      lesspipe(tail: true) do |less|
+        groups = log_events.split_between { |a,b| (b.date.to_i - a.date.to_i) > 60 }
+
+        groups.each do |group|
+          first, last = group.first.date, group.last.date
+          elapsed     = (last.to_i - first.to_i) / 60
+
+          empty_group = true
+
+          group.each do |ev|
+            # Print the header only if the query matched something in this group
+            if empty_group
+              empty_group = false
+              less.puts
+              less.puts "<8>== <11>#{first.strftime("<10>%Y-%m-%d <7>at <2>%l:%M %p")} <7>(<9>#{elapsed} <7>minute session) <8>========".colorize
+            end
+
+            less.puts ev
+          end
+        end
+      end # lesspipe
+    end
+
+  end # LogParser
+end

data/lib/upm/tool.rb

@@ -0,0 +1,180 @@
+
+# os:<pkg> -- automatically select the package manager for the current unix distribution
+# deb:<pkg> (or d: u:)
+# rpm:<pkg> (or yum: y:)
+# bsd:<pkg> (or b:)
+# ruby:<pkg> (or r: gem:)
+# python:<pkg>,<pkg> (or py: p: pip:)
+
+module UPM
+
+  class Tool
+
+    COMMAND_HELP = {
+      "install"          => "install a package",
+      "remove/uninstall" => "remove a package",
+      "build"            => "compile a package from source and install it",
+      "search"           => "using the fastest known API or service",
+      "list"             => "list installed packages (or search their names if extra arguments are supplied)",
+      "info"             => "show metadata about a package",
+      "sync/update"      => "retrieve the latest package list or manifest",
+      "upgrade"          => "install new versions of all 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",
+      "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')",
+    }
+
+    ALIASES = {
+      "file"    => "files",
+      "sync"    => "update",
+      "sources" => "mirrors",
+      "show"    => "info",
+    }
+
+    @@tools = {}
+
+    def self.register_tools!
+      Dir["#{__dir__}/tools/*.rb"].each { |lib| require_relative(lib) }
+    end
+
+    def self.os_release
+      @os_release ||= open("/etc/os-release") do |io|
+        io.read.scan(/^(\w+)="?(.+?)"?$/)
+      end.to_h
+    end
+
+    def self.current_os_names
+      # ID=ubuntu
+      # ID_LIKE=debian
+      os_release.values_at("ID", "ID_LIKE")
+    end
+
+    def self.nice_os_name
+      os_release.values_at("PRETTY_NAME", "NAME", "ID", "ID_LIKE").first
+    end
+
+    def self.for_os(os_names=nil)
+      os_names = os_names ? [os_names].flatten : current_os_names
+      @@tools.find { |name, tool| os_names.any? { |name| tool.os.include? name } }.last
+    end
+
+    def self.tools
+      @@tools
+    end
+
+    def initialize(name, &block)
+      @name = name
+      instance_eval(&block)
+
+      @@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
+      puts "    Detected OS: #{Tool.nice_os_name}"
+      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
+
+    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
+
+    ## DSL methods
+
+    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
+
+        shell_command.unshift "sudo" if root
+
+        @cmds[name] = proc { |args| run(*shell_command, *args, paged: paged) }
+      end
+    end
+
+    def os(*names)
+      names.any? ? @os = names : @os
+    end
+
+    ## Helpers
+
+    def run(*args, paged: false, grep: nil)
+      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
+
+  end # class Tool
+
+end # module UPM
+

data/lib/upm/tools/apt.rb

@@ -0,0 +1,68 @@
+UPM::Tool.new "apt" do
+
+  os "debian", "ubuntu"
+
+  command "install",  "apt install", root: true
+  command "update",   "apt update",  root: true
+  command "upgrade",  "apt upgrade", root: true
+  command "remove",   "apt remove",  root: true
+
+  command "files",  "dpkg-query -L", paged: true
+  command "search", "apt search",    paged: true
+  command "info",   "apt show",      paged: true
+
+  command "list" do |args|
+    if args.any?
+      query = args.join
+      run("dpkg", "-l", grep: query, paged: true)
+    else
+      run("dpkg", "-l", paged: true)
+    end
+  end
+  
+  command "mirrors" do
+    print_files("/etc/apt/sources.list", *Dir["/etc/apt/sources.list.d/*"], exclude: /^(#|$)/)
+  end
+
+  command "log" do
+    UPM::LogParser.new(DpkgEvent, "/var/log/dpkg*").display
+  end
+
+  class DpkgEvent < Struct.new(:datestr, :date, :cmd, :name, :v1, :v2)
+
+    # 2010-12-03 01:36:56 remove gir1.0-mutter-2.31 2.31.5-0ubuntu9 2.31.5-0ubuntu9
+    # 2010-12-03 01:36:58 install gir1.0-mutter-2.91 <none> 2.91.2+git20101114.982a10ac-0ubuntu1~11.04~ricotz0  
+    #LINE_RE = /^(.+ .+) (status \w+|\w+) (.+) (.+)$/
+    LINE_RE = /^(.+ .+) (remove|install|upgrade) (.+) (.+) (.+)$/
+
+    CMD_COLORS = {
+      'remove' => :light_red,
+      'install' => :light_yellow,
+      'upgrade' => :light_green,
+      nil => :white,
+    }
+    
+    def self.parse_date(date)
+      DateTime.strptime(date, "%Y-%m-%d %H:%M:%S")
+    end
+   
+    def self.from_line(line)
+      if line =~ LINE_RE
+        new($1, parse_date($1), $2, $3, $4, $5)
+      else
+        nil
+      end
+    end    
+    
+    def cmd_color
+      CMD_COLORS[cmd]
+    end
+
+    def to_s
+      date, time = datestr.split
+      "<grey>[<white>#{date} #{time}<grey>] <#{cmd_color}>#{cmd} <light_cyan>#{name} <light_white>#{v2} <white>(#{v1})".colorize
+    end  
+
+  end
+      
+end

data/lib/upm/tools/pacman.rb

@@ -0,0 +1,105 @@
+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 "remove",  [*bin, "-R"],   root: 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)
+  end
+
+  command "list" do |args|
+    if args.any?
+      query = args.join
+      run(*bin, "-Q", grep: query, paged: true)
+    else
+      run(*bin, "-Q", paged: true)
+    end
+  end
+
+  command "mirrors" do
+    print_files("/etc/pacman.d/mirrorlist", exclude: /^(#|$)/)
+  end
+
+  command "depends" do |args|
+    packages_that_depend_on = proc do |package|
+      result = []
+
+      [`pacman -Sii #{package}`, `pacman -Qi #{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 |arg|
+      puts "=== Packages which depend on: #{arg} ============"
+      packages = packages_that_depend_on.call(arg)
+      puts
+      run *bin, "-Ss", "^(#{packages.join '|'})$" # upstream packages
+      run *bin, "-Qs", "^(#{packages.join '|'})$" # packages that are only installed locally
+      puts
+    end
+  end
+
+  command "log" do
+    UPM::LogParser.new(PacmanEvent, "/var/log/pacman.log*").display
+  end
+
+  class PacmanEvent < Struct.new(:datestr, :date, :cmd, :name, :v1, :v2)
+
+    # [2015-01-04 04:21] [PACMAN] installed lib32-libidn (1.29-1)
+    # [2015-01-04 04:21] [PACMAN] upgraded lib32-curl (7.38.0-1 -> 7.39.0-1)
+    # [2015-01-07 04:39] [ALPM] upgraded intel-tbb (4.3_20141023-1 -> 4.3_20141204-1)
+    # [2015-01-07 04:39] [ALPM] upgraded iso-codes (3.54-1 -> 3.57-1)
+
+    DATE_RE = /[\d:-]+/
+    LINE_RE = /^\[(#{DATE_RE} #{DATE_RE})\](?: \[(?:PACMAN|ALPM)\])? (removed|installed|upgraded) (.+) \((.+)(?: -> (.+))?\)$/
+
+    CMD_COLORS = {
+      'removed' => :light_red,
+      'installed' => :light_yellow,
+      'upgraded' => :light_green,
+      nil => :white,
+    }
+
+    def self.parse_date(date)
+      DateTime.strptime(date, "%Y-%m-%d %H:%M")
+    end
+
+    def self.from_line(line)
+      if line =~ LINE_RE
+        new($1, parse_date($1), $2, $3, $4, $5)
+      else
+        nil
+      end
+    end
+
+    def cmd_color
+      CMD_COLORS[cmd]
+    end
+
+    def to_s
+      date, time = datestr.split
+      "<grey>[<white>#{date} #{time}<grey>] <#{cmd_color}>#{cmd} <light_cyan>#{name} #{"<light_white>#{v2} " if v2}<white>(#{v1})".colorize
+    end
+
+  end
+
+
+end
+
+

data/lib/upm/tools/xbps.rb

@@ -0,0 +1,20 @@
+UPM::Tool.new "xbps" do
+
+  os "void"
+
+  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 "list" do |args|
+    if args.any?
+      run "xbps-query", "-f", *args
+    else
+      run "xbps-query", "-l"
+    end
+  end
+
+end

data/lib/upm.rb

@@ -0,0 +1,12 @@
+require 'upm/colored'
+require 'upm/lesspipe'
+require 'upm/core_ext'
+require 'upm/log_parser'
+
+module UPM
+
+  require 'upm/tool'
+
+  Tool.register_tools!
+
+end

metadata

@@ -1,29 +1,42 @@
 --- !ruby/object:Gem::Specification
 name: upm
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.0
 platform: ruby
 authors:
 - epitron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-12 00:00:00.000000000 Z
+date: 2018-05-04 00:00:00.000000000 Z
 dependencies: []
 description: Wrap all known command-line package tools with a consistent and pretty
   interface.
 email: chris@ill-logic.com
-executables: []
+executables:
+- upm
 extensions: []
 extra_rdoc_files:
 - README.md
 - LICENSE
 files:
 - ".gemspec"
+- ".gitignore"
 - LICENSE
 - README.md
 - Rakefile
+- TODO.md
 - VERSION
+- bin/upm
+- lib/upm.rb
+- lib/upm/colored.rb
+- lib/upm/core_ext.rb
+- lib/upm/lesspipe.rb
+- lib/upm/log_parser.rb
+- lib/upm/tool.rb
+- lib/upm/tools/apt.rb
+- lib/upm/tools/pacman.rb
+- lib/upm/tools/xbps.rb
 homepage: http://github.com/epitron/upm/
 licenses:
 - WTFPL
@@ -44,9 +57,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Universal Package Manager
 test_files: []
-has_rdoc: