riel 1.0.0

data/lib/riel/optproc.rb

@@ -0,0 +1,369 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'riel/env'
+require 'riel/log'
+require 'riel/text'
+require 'riel/enumerable'
+
+
+module OptProc
+
+  class Option
+    include Loggable
+
+    attr_reader :md, :tags, :res
+
+    ARG_INTEGER = %r{^ ([\-\+]?\d+)               $ }x
+    ARG_FLOAT   = %r{^ ([\-\+]?\d* (?:\.\d+)?)    $ }x
+    ARG_STRING  = %r{^ [\"\']? (.*?) [\"\']?      $ }x
+    ARG_BOOLEAN = %r{^ (yes|true|on|no|false|off) $ }ix
+
+    ARG_TYPES = Array.new
+    ARG_TYPES << [ :integer, ARG_INTEGER ]
+    ARG_TYPES << [ :float,   ARG_FLOAT   ]
+    ARG_TYPES << [ :string,  ARG_STRING  ]
+    ARG_TYPES << [ :boolean, ARG_BOOLEAN ]
+
+    def initialize(args = Hash.new, &blk)
+      @tags    = args[:tags] || Array.new
+      @rc      = args[:rc]
+      @rc      = [ @rc ] if @rc.kind_of?(String)
+      @md      = nil
+      @set     = blk || args[:set]
+      
+      @type    = nil
+      @valuere = nil
+      
+      @argtype = nil
+
+      @res     = args[:res]
+      @res     = [ @res ] if @res.kind_of?(Regexp)
+      
+      if args[:arg]
+        # log { "args.class: #{args[:arg].class}" }
+        demargs = args[:arg].dup
+        while arg = demargs.shift
+          # log { "arg: #{arg}" }
+          case arg
+          when :required
+            @type = "required"
+          when :optional
+            @type = "optional"
+          when :none
+            @type = nil
+          when :regexp
+            @valuere = demargs.shift
+          else
+            if re = ARG_TYPES.assoc(arg)
+              # log { "re: #{re}" }
+              @valuere   = re[1]
+              @argtype   = arg
+              @type    ||= "required"
+            else
+              # log { "no expression for arg #{arg}" }
+            end
+          end
+        end
+      end
+
+      # log { "valuere: #{@valuere}" }
+      # log { "type: #{@type}" }
+    end
+
+    def inspect
+      '[' + @tags.collect { |t| t.inspect }.join(" ") + ']'
+    end
+
+    def to_str
+      to_s
+    end
+
+    def to_s
+      @tags.join(" ")
+    end
+
+    def match_rc?(field)
+      @rc && @rc.include?(field)
+    end
+
+    def match_value(val)
+      # log { "valuere: #{@valuere.inspect}; val: #{val}" }
+      @md = @valuere && @valuere.match(val)
+      # log { "md: #{@md.inspect}" }
+      @md && @md[1]
+    end
+
+    def match_tag(tag)
+      stack { "@rc: #{@rc.inspect}; @tags: #{@tags.inspect}" }
+
+      if tm = @tags.detect do |t|
+          log { "t: #{t}; tag: #{tag}; idx: #{t.index(tag)}" }
+          t.index(tag) == 0 && tag.length <= t.length
+        end
+        
+        log { "tm: #{tm}" }
+        if tag.length == tm.length
+          1.0
+        else
+          len = tag.length.to_f * 0.01 #  / tm.length
+          log { "len: #{len}" }
+          len
+        end
+      else
+        nil
+      end
+    end
+    
+    def match(args, opt = args[0])
+      return nil unless %r{^-}.match(opt)
+
+      # log { "opt: #{opt.inspect}; args: #{args.inspect}" }
+      # log { "@rc: #{@rc.inspect}; @re: #{@re.inspect}; @tags: #{@tags.inspect}" }
+
+      tag, val = opt.split('=', 2)
+      tag ||= opt
+
+      # log { "opt: #{opt}; opt: #{opt.class}; tag: #{tag}; tags: #{@tags.inspect}" }
+      # log { "res: #{@res.inspect}" }
+
+      @md = nil
+      
+      if @res && (@md = @res.collect { |re| re.match(opt) }.detect)
+        # log { "matched: #{@md}" }
+        1.0
+      else
+        match_tag(tag)
+      end
+    end
+
+    def set_value(args, opt = args[0])
+      tag, val = opt.split('=', 2)
+      args.shift
+      
+      # log { "opt : #{opt}" }
+      # log { "tag : #{tag}" }
+      # log { "tags: #{@tags.inspect}" }
+      # log { "val : #{val.inspect}" }
+      # log { "md  : #{@md.inspect}" }
+
+      if @md
+        # log { "already have match data" }
+      elsif @type == "required"
+        if val
+          # already have value
+          # log { "already have value: #{val}" }
+        elsif args.size > 0
+          val = args.shift
+          # log { "got next value: #{val}" }
+        else
+          $stderr.puts "value expected"
+        end
+
+        if val
+          match_value(val)
+        end
+      elsif @type == "optional"
+        if val
+          # log { "already have value: #{val}" }
+          match_value(val)
+        elsif args.size > 0
+          if %r{^-}.match(args[0])
+            # log { "skipping next value; apparently option" }
+          elsif match_value(args[0])
+            # log { "value matches: #{val}" }
+            args.shift
+          else
+            # log { "value does not match" }
+          end
+        end
+      else
+        # log { "no type" }
+      end
+
+      value = value_from_match
+
+      set(value, opt, args)
+    end
+
+    def value_from_match
+      if @md 
+        if @argtype.nil? || @argtype == :regexp
+          @md
+        else
+          convert_value(@md[1])
+        end
+      elsif @argtype == :boolean
+        true
+      end
+    end
+
+    def convert_value(val)
+      if val
+        case @argtype
+        when :string
+          val
+        when :integer
+          val.to_i
+        when :float
+          val.to_f
+        when :boolean
+          to_boolean(val)
+        when :regexp
+          val
+        when nil
+          val
+        else
+          log { "unknown argument type: #{@type.inspect}" }
+        end
+      elsif @argtype == :boolean
+        true
+      end
+    end
+
+    def to_boolean(val)
+      %w{ yes true on soitenly }.include?(val.downcase)
+    end
+
+    def set(val, opt = nil, args = nil)
+      # log { "argtype: #{@argtype}; md: #{@md.inspect}" }
+
+      setargs = [ val, opt, args ].select_with_index { |x, i| i < @set.arity }
+      # log "val: #{val}"
+      @set.call(*setargs)
+    end
+  end
+
+
+  class OptionSet
+    include Loggable
+
+    attr_reader :options
+    
+    def initialize(data)
+      @options   = Array.new
+      @shortopts = Array.new
+      @longopts  = Array.new
+      @regexps   = Hash.new
+      
+      data.each do |optdata|
+        opt = OptProc::Option.new(optdata)
+        @options << opt
+
+        opt.tags.each do |tag|
+          ch = tag[0]
+          if ch == 45  # 45 = '-'
+            ch = tag[1]
+            assocopts = nil
+            if ch == tag
+              ch = tag[2]
+              assocopts = @longopts
+            else
+              assocopts = @shortopts
+            end
+            
+            (assocopts[ch] ||= Array.new) << opt
+          end
+          
+          if res = opt.res
+            res.each do |re|
+              (@regexps[re] ||= Array.new) << opt
+            end
+          end
+        end
+      end
+
+      if false
+        [ @longopts, @shortopts ].each do |list|
+          list.each_with_index do |v, idx|
+            log { "#{idx} => #{v.inspect}" }
+          end
+        end
+        [ @regexps ].each do |map|
+          map.each do |k, v|
+            log { "#{k} => #{v.inspect}" }
+          end
+        end
+      end
+
+    end
+
+    COMBINED_OPTS_RES = [
+      #               -number     non-num, then anything
+      Regexp.new('^ ( - \d+   )  ( \D+.* ) $ ', Regexp::EXTENDED),
+      #               -letter     anything
+      Regexp.new('^ ( - [a-z] )  ( .+    ) $ ', Regexp::EXTENDED)
+    ]
+
+    def process_option(args)
+      opt = args[0]
+
+      # log { "processing option #{opt}" }
+
+      if md = COMBINED_OPTS_RES.collect { |re| re.match(opt) }.detect
+        lhs = md[1]
+        rhs = "-" + md[2]
+
+        # log { "lhs, rhs: #{lhs.inspect}, #{rhs.inspect}" }
+        
+        args[0, 1] = lhs, rhs
+        
+        return process_option(args)
+      elsif opt[0] == 45
+        ch = opt[1]
+        assocopts = if ch == 45  # 45 = '-'
+                      ch = opt[2]
+                      @longopts[ch]
+                    elsif ch.nil?
+                      nil
+                    else
+                      @shortopts[ch]
+                    end
+
+        # log { "opts: #{assocopts.inspect}" }
+        if assocopts && x = set_option(assocopts, args)
+          return x
+        end
+      end
+
+      if x = set_option(@options, args)
+        return x
+      elsif @bestmatch
+        # what's the best match here ...?
+        log { "bestmatch: #{@bestmatch}" }
+        log { "bestopts : #{@bestopts.inspect}" }
+        if @bestopts.size == 1
+          @bestopts[0].set_value(args)
+          return @bestopts[0]
+        else
+          optstr = @bestopts.collect { |x| '(' + x.tags.join(', ') + ')' }.join(', ')
+          $stderr.puts "ERROR: ambiguous match of '#{args[0]}'; matches options: #{optstr}"
+          exit 2
+        end
+      end
+
+      nil
+    end
+
+    def set_option(optlist, args)
+      @bestmatch = nil
+      @bestopts  = Array.new
+      
+      optlist.each do |option|
+        if mv = option.match(args)
+          if mv >= 1.0
+            # exact match:
+            option.set_value(args)
+            return option
+          elsif !@bestmatch || @bestmatch <= mv
+            @bestmatch = mv
+            @bestopts  << option
+          end
+        end
+      end
+      nil
+    end
+    
+  end
+
+end

data/lib/riel/pathname.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'pathname'
+require 'riel/string'
+
+
+class Pathname
+
+  # a compliment to the +dirname+, +basename+, and +extname+ family, this returns
+  # the basename without the extension, e.g. "foo" from "/usr/share/lib/foo.bar".
+  def rootname
+    basename.to_s - extname.to_s
+  end
+
+end

data/lib/riel/rcfile.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+
+# Represents a resource file, where '#' is used to comment to end of lines, and
+# name/value pairs are separated by '=' or ':'.
+
+class RCFile
+
+  attr_reader :settings
+
+  # Reads the RC file, if it exists, and if a block is passed, calls the block
+  # with each name/value pair, which are also accessible via
+  # <code>settings</code>.
+
+  def initialize(fname, &blk)
+    @settings = Array.new
+    
+    if File.exists?(fname)
+      IO.readlines(fname).each do |line|
+        line.sub!(/\s*#.*/, "")
+        line.chomp!
+        name, value = line.split(/\s*[=:]\s*/)
+        if name && value
+          name.strip!
+          value.strip!
+          @settings << [ name, value ]
+          if blk
+            blk.call(name, value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/riel/regexp.rb

@@ -0,0 +1,152 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+# Negates the given expression.
+class NegatedRegexp < Regexp
+
+  def match(str)
+    !super
+  end
+
+end
+
+class Regexp
+
+  # shell expressions to Ruby regular expression sequences
+  SH2RE = Hash[
+    '*'  => '.*', 
+    '?'  => '.',
+    # '['  => '\[',
+    # ']'  => '\]',
+    '.'  => '\.',
+    '$'  => '\$',
+    '/'  => '\/',
+    '('  => '\(',
+    ')'  => '\)',
+  ]
+
+  # Returns a regular expression for the given Unix file system expression.
+  
+  def self.unixre_to_string(pat)
+    pat.gsub(%r{(\\.)|(.)}) do
+      $1 || SH2RE[$2] || $2
+    end
+  end
+
+  WORD_START_RE = Regexp.new('^                 # start of word
+                                [\[\(]*         # parentheses or captures, maybe
+                                (?: \\\w | \\w) # literal \w, or what \w matches
+                              ',
+                             Regexp::EXTENDED)
+  
+  WORD_END_RE = Regexp.new('(?:                 # one of the following:
+                                \\\w            #   - \w for regexp
+                              |                 # 
+                                \w              #   - a literal A-Z, a-z, 0-9, or _
+                              |                 # 
+                                (?:             #   - one of the following:
+                                    \[[^\]]*    #         LB, with no RB until:
+                                    (?:         #      - either of:
+                                        \\w     #         - "\w"
+                                      |         # 
+                                        \w      #         - a literal A-Z, a-z, 0-9, or _
+                                    )           #      
+                                    [^\]]*\]    #      - anything (except RB) to the next RB
+                                )               #
+                            )                   #
+                            (?:                 # optionally, one of the following:
+                                \*              #   - "*"
+                              |                 # 
+                                \+              #   - "+"
+                              |                 #
+                                \?              #   - "?"
+                              |                 #
+                                \{\d*,\d*\}   #   - "{3,4}", "{,4}, "{,123}" (also matches the invalid {,})
+                            )?                  #
+                            $                   # fin
+                           ', 
+                           Regexp::EXTENDED)
+
+  # Handles negation, whole words, and ignore case (Ruby no longer supports
+  # Rexexp.new(/foo/i), as of 1.8).
+  
+  def self.create(pat, args = Hash.new)
+    negated    = args[:negated]
+    ignorecase = args[:ignorecase]
+    wholewords = args[:wholewords]
+    wholelines = args[:wholelines]
+    extended   = args[:extended]
+    multiline  = args[:multiline]
+
+    pattern    = pat.dup
+    
+    # we handle a ridiculous number of possibilities here:
+    #     /foobar/     -- "foobar"
+    #     /foo/bar/    -- "foo", then slash, then "bar"
+    #     /foo\/bar/   -- same as above
+    #     /foo/bar/i   -- same as above, case insensitive
+    #     /foo/bari    -- "/foo/bari" exactly
+    #     /foo/bar\/i  -- "/foo/bar/i" exactly
+    #     foo/bar/     -- "foo/bar/" exactly
+    #     foo/bar/     -- "foo/bar/" exactly
+
+    if pattern.sub!(%r{ ^ !(?=/) }x, "")
+      negated = true
+    end
+
+    if pattern.sub!(%r{ ^ \/ (.*[^\\]) \/ ([mix]+) $ }x) { $1 }
+      modifiers  = $2
+      
+      multiline  ||= modifiers.index('m')
+      ignorecase ||= modifiers.index('i')
+      extended   ||= modifiers.index('x')
+    else
+      pattern.sub!(%r{ ^\/ (.*[^\\]) \/ $ }x) { $1 }
+    end
+    
+    if wholewords
+      # sanity check:
+
+      errs = [
+        [ WORD_START_RE, "start" ],
+        [ WORD_END_RE,   "end"   ]
+      ].collect do |ary|
+        re, err = *ary
+        re.match(pattern) ? nil : err
+      end.compact
+      
+      if errs.length > 0
+        Log.warn "pattern '#{pattern}' does not " + errs.join(" and ") + " on a word boundary"
+      end
+      pattern = '\b' + pattern + '\b'
+    elsif wholelines
+      pattern = '^'  + pattern + '$'        # ' for emacs
+    end
+    
+    reclass = negated ? NegatedRegexp : Regexp
+
+    flags = [
+      [ ignorecase, Regexp::IGNORECASE ],
+      [ extended,   Regexp::EXTENDED   ],
+      [ multiline,  Regexp::MULTILINE  ]
+    ].inject(0) do |tot, ary|
+      val, flag = *ary
+      tot | (val ? flag : 0)
+    end
+    
+    reclass.new(pattern, flags)
+  end
+
+  def self.matches_word_start?(pat)
+    WORD_START_RE.match(pat)
+  end
+
+  def self.matches_word_end?(pat)
+    WORD_END_RE.match(pat)
+  end
+
+  # applies Perl-style substitution (s/foo/bar/).
+  def self.perl_subst(pat)
+  end
+  
+end

data/lib/riel/setdiff.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+# Compares two enumerables, treating them as sets, showing whether they are
+# identical, A contains B, B contains A, or A and B contain common elements.
+
+class SetDiff
+  def SetDiff.new(a, b)
+    allitems = a | b
+
+    a_and_b    = Array.new
+    a_not_in_b = Array.new
+    b_not_in_a = Array.new
+
+    allitems.each do |it|
+      if a.include?(it)
+        if b.include?(it)
+          a_and_b
+        else
+          a_not_in_b
+        end
+      else
+        b_not_in_a
+      end << it
+    end
+    
+    super(a_and_b, a_not_in_b, b_not_in_a)
+  end
+
+  attr_reader :a_and_b, :a_not_in_b, :b_not_in_a
+
+  def initialize(a_and_b, a_not_in_b, b_not_in_a)
+    @a_and_b    = a_and_b
+    @a_not_in_b = a_not_in_b
+    @b_not_in_a = b_not_in_a
+  end
+
+  def diff_type
+    @diff_type ||= if @a_and_b.empty?
+                     :no_common
+                   elsif @a_not_in_b.empty?
+                     if @b_not_in_a.empty?
+                       :identical
+                     else
+                       :b_contains_a
+                     end
+                   elsif @b_not_in_a.empty?
+                     :a_contains_b
+                   else
+                     :common
+                   end
+  end
+end

data/lib/riel/size_converter.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+class SizeConverter
+  # http://www.gnu.org/software/coreutils/manual/html_node/Block-size.html
+
+  # don't round to closest -- just convert
+  def self.convert_to_kilobytes(size, decimal_places = 1)
+    ### SizeConverter._convert(Human::CONVERSIONS, 2, size, decimal_places)
+  end
+
+  class Human
+    CONVERSIONS = [ 
+      [ 12, "T" ],
+      [  9, "G" ],
+      [  6, "M" ],
+      [  3, "K" ]
+    ]
+
+    # returns a string representation of the size. Note that K, G, M are
+    # gibibytes, etc., that is, powers of 10.
+    
+    def self.convert(size, decimal_places = 1)
+      SizeConverter._convert(CONVERSIONS, 10, size, decimal_places)
+    end
+  end
+
+  class SI
+    # http://physics.nist.gov/cuu/Units/binary.html
+    CONVERSIONS = [ 
+      [ 40, "TiB" ],
+      [ 30, "GiB" ],
+      [ 20, "MiB" ],
+      [ 10, "KiB" ]
+    ]
+
+    # returns a string representation of the size. Note that K, G, M are
+    # gigabytes, etc.
+    
+    def self.convert(size, decimal_places = 1)
+      SizeConverter._convert(CONVERSIONS, 2, size, decimal_places)
+    end
+  end
+
+  # legacy:
+
+  def self.convert(size, decimal_places = 1)
+    Human::convert(size, decimal_places)
+  end
+
+  def self._convert(conversions, base, size, decimal_places)
+    sizef = size.to_f
+    conversions.each do |conv|
+      sz = sizef / (base ** conv[0])
+      if sz >= 1.0
+        return sprintf("%.*f%s", decimal_places, sz, conv[1])
+      end
+    end
+
+    sprintf("%.*f", decimal_places, size)
+  end
+end