noms-optconfig 1.5.3

data/bin/bash-showconfig

@@ -0,0 +1,53 @@
+#!/bin/bash
+
+#
+# Copyright 2014 Evernote Corp. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+
+domain="$1"
+shift 1
+
+SCRIPT_VERSION=$(ruby -rubygems -e 'require "optconfig/version"; puts Optconfig::VERSION')
+
+echo -n "Using "; which optconfig.sh
+. optconfig.sh
+opt_new_gen $domain "$@"
+
+:<<EOF
+=head1 NAME
+
+bash_showconfig - Display the standard configuration resulting from given options
+
+=head1 SYNOPSIS
+
+   bash_showconfig domain optspec [options]
+
+=head1 DESCRIPTION
+
+The standard Optconfig system provides a way to configure program execution
+in the context specified by domain. Optionally the "perl" or "ruby" languages
+can be specified to use those code paths.
+
+The optspec is a JSON-serialized option specifier (see L<Optconfig>). Other
+arguments are passed to the optconfig module (perl or ruby) to determine the
+final configuration.
+
+=head1 AUTHOR
+
+Jeremy Brinkley, E<lt>jbrinkley@evernote.comE<gt>
+
+=cut
+EOF

data/bin/optconfig.sh

@@ -0,0 +1,128 @@
+#!bash
+
+# Copyright 2013 Proofpoint, Inc. All rights reserved.
+# Copyright 2014 Evernote Corp. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# TODO:
+# * --version doesn't really work, calling script continues after printing
+# version.
+# * --help doesn't work (because a) it prints the help on the stdout
+# which is what gets eval'd, and b) it'll never find "-e"
+# opt_new doesn't work, you have to eval it yourself, because otherwise
+# the 'set' command which rearranges the script arguments doesn't work
+# -jdb/20100921
+
+opt_new_gen()
+{
+   local domain optspec
+   domain="$1"
+   shift 1
+   optspec="$1"
+   shift 1
+   ruby -rubygems \
+      -e 'require "optconfig"' \
+      -e 'require "json"' \
+      -e 'require "bashon"' \
+      -e '$VERSION = "'$SCRIPT_VERSION'"' \
+      -e '$0 = "'"$0"'"' \
+      -e 'd = ARGV.shift' \
+      -e 'opttext = ARGV.shift' \
+      -e 'optspec = JSON.load(opttext)' \
+      -e 'opt = Optconfig.new(d, optspec)' \
+      -e 'puts opt.map { |k,v| v.to_bashon("opt", d, k) }.join(";") + ";" +' \
+      -e '   "opt_#{d}_vrb() { local l=\"$1\"; shift 1; test $l -le $(opt_#{d}_verbose) && echo $*; };" + ' \
+      -e '   "opt_#{d}_dbg() { local l=\"$1\"; shift 1; test $l -le $(opt_#{d}_debug) && echo \"DBG(#{d}):\" $*; };" + ' \
+      -e '   "opt_#{d}_dry() { if opt_#{d}_dry_run; then echo $*; else \"$@\"; fi; };" + ' \
+      -e '   "opt_#{d}() { c=\"${1//[^a-zA-Z0-9]/_}\"; shift 1; opt_#{d}_$c \"$@\"; };" + ' \
+      -e '   "set -- #{ARGV.map {|a| 39.chr + a + 39.chr}.join(%q( ))}"' \
+      "$domain" "$optspec" "$@"
+}
+
+json2bashon_gen()
+{
+   ruby -rubygems \
+      -e 'require "bashon"' \
+      -e 'require "json"' \
+      -e 'name = ARGV.shift' \
+      -e 'json_text = ARGV.shift' \
+      -e 'obj = JSON.load(json_text)' \
+      -e 'puts obj.to_bashon(name)' "$@"
+}
+
+json2bashon()
+{
+   eval `json2bashon_gen "$@"`
+}
+
+opt_new()
+{
+   # This doesn't work, but this is how it should work
+   eval `opt_new_gen "$@"`
+   echo opt_$1
+}
+
+:<<'EOF'
+=head1 NAME
+
+optconfig - Bash functions for option parsing
+
+=head1 SYNOPSIS
+
+   . optconfig.sh
+   domain=domain
+   optspec='{ "force!": false,
+      "logfile=s": "/var/log/foo",
+      "define=s%": { } }'
+   # opt=`opt_new $domain $optspec`
+   eval `opt_new_gen $domain "$optspec" "$@"`
+   opt=opt_$domain
+
+   if $opt force
+   then
+      rm -f $filefoo
+   fi
+
+   echo "Message" >>`$opt logfile`
+
+   for key in `$opt define`
+   do
+      valfun=`$opt define $key`
+      val=`$valfun`               # Note this call--all hash values are funs
+      echo "$key = $val"
+   done
+
+=head1 DESCRIPTION
+
+This bash "module" implements a common config file and command-line option
+parsing interface, including Optconfig standard options, that is shared with
+the Optconfig Perl module. See that module for details.
+
+The initial call is a wrapper around the Ruby optconfig option and config
+parsing library, and the results are serialized using the L<bashon> module.
+
+=head1 NOTES
+
+Pay careful attention to how L<bashon> serializes values, especially
+collections. In particular the "leaf" value of a collection is always itself a
+function. If the leaf is itself a collection, this will result in many command
+invocations before you reach a simple value.
+
+=head1 AUTHOR
+
+Jeremy Brinkley, E<lt>jbrinkley@evernote.comE<gt>
+
+=cut
+EOF

data/bin/ruby-showconfig

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+# Copyright 2014 Evernote Corp. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'optconfig'
+
+$VERSION = Optconfig::VERSION
+
+lib_location = $LOADED_FEATURES.find { |f| f =~ /optconfig.rb$/ }
+
+puts "Using #{lib_location}"
+
+domain = ARGV.shift
+optspec = JSON.load(ARGV.shift)
+opt = Optconfig.new(domain, optspec)
+puts opt.to_json
+
+# = NAME
+#
+# showconfig - Display the standard configuration resulting from given options
+#
+# = SYNOPSIS
+#
+#   ruby-showconfig domain optspec [options]
+#
+# = DESCRIPTION
+#
+# The standard Optconfig system provides a way to configure program execution
+# in the context specified by domain.
+#
+# The optspec is a JSON-serialized option specifier (see Optconfig). Other
+# arguments are passed to the optconfig module to determine the
+# final configuration.
+#
+# = AUTHOR
+#
+# Jeremy Brinkley, <jbrinkley@evernote.com>
+#

data/lib/bashon.rb

@@ -0,0 +1,346 @@
+#!ruby
+# /* Copyright 2013 Proofpoint, Inc. All rights reserved.
+#    Copyright 2014 Evernote Corp. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# */
+
+module BashOn
+   def name_key(name)
+      name.join('_').gsub(/[^a-zA-Z0-9\_]/, '_')
+   end
+
+   @@manpage = <<EOF
+=head1 NAME
+
+bashon - Serialization library for bash object notation
+
+=head1 SYNOPSIS
+
+   require 'bashon'
+
+   puts var.to_bashon('var')
+
+=head1 DESCRIPTION
+
+This module enables you to serialize some ruby objects as "bashon" objects
+("bashon meaning bash object notation"). Mostly, this means that bash code is
+emitted that creates functions returning (echoing) the proper value.
+
+The name that is passed to the B<to_bashon> method is the name of the function
+that will output the serialized value. It also forms the root of a hierarchy of
+function names that are used for serializing complex (array and hash) types.
+
+The output is expected to be evaluated using the L<eval> command in bash.
+
+=head2 Types
+
+=head3 Nils
+
+An unset command is emitted.
+
+=head3 Booleans
+
+A function is created with the specified name that can be used as a truth
+test. That is, the function exits with a true value when serializing the
+C<true> literal and with a false value when serializing the C<false>
+literal. This enables you to use the resulting functions directly in
+conditionals in bash.
+
+=head3 Other simple types
+
+A function is created with the specified name that outputs the value of the
+type using B<to_s>.
+
+=head3 Complex types
+
+The important thing to note about complex types (hashes and arrays) is that
+the values in the collection are always the I<names of functions> that, when
+invoked, will yield a bashon-serialized value. This is especially important
+to remember when the value of a hash entry or array element is itself a
+complex type.
+
+=head4 Arrays
+
+A function is created with the specified name that outputs a space-separated,
+ordered list of function names. Each function name is also created; when the
+function is invoked, it will yield the value of that element.
+
+head4 Hashes
+
+A function is created with the specified name that outputs a space-separated
+list of hash keys. When the same function is invoked with a hash key as an
+argument, it outputs the name of a function. That function, when invoked,
+will yield the value of that element.
+
+=head1 EXAMPLES
+
+In the following example, each example is shown with three blocks: the ruby
+code snippet emitting the serialization, its standard output, and a shell
+session in which the resulting code has been eval'd
+
+This shows how a boolean value is serialized:
+
+   puts true.to_bashon('var')
+
+   function var { return 0; }
+
+   $ if var; then echo got it; fi
+   got it
+
+This shows how a nil value is serialized:
+
+   puts nil.to_bashon('var')
+
+   unset var
+
+   $ if [ -z "$(var)" ]; then echo No var; fi
+   No var
+
+This shows how a string is serialized and used:
+
+   puts "catalog data".to_bashon('var')
+
+   function var { echo catalog data; }
+
+   $ string=$(var)
+   $ echo $string
+   catalago data
+
+This shows how an array of strings is serialized:
+
+   puts ["file1", "file2", "file3"].to_bashon('var')
+
+   function var { echo var_0 var_1 var_2; } ; function var_0 { echo file1; };function var_1 { echo file2; };function var_2 { echo file3; }
+
+   $ for filefun in $(var); do file=$($filefun); touch $file; done; ls file*
+   file1   file2   file3
+
+And a hash of strings:
+
+   var = { "log" => "logfile.txt",
+           "err" => "errfile.txt",
+           "input" => "data.txt" }
+   puts var.to_bashon('var')
+
+   function var { case "$1" in log) echo var_log;; err) echo var_err;; input) echo var_input;; '') echo log err input;; esac; }; function var_log { echo logfile.txt; };function var_err { echo errfile.txt; };function var_input { echo data.txt; }
+
+   $ for key in $(var); do valfun=$(var $key); val=$($valfun); echo $key=$val; done
+   log=logfile.txt
+   err=errfile.txt
+   input=data.txt
+   $ echo "Error message" >>$($(var err))
+
+This shows how to deal with a heterogeneous array:
+
+   var = ['one', { 'type' => 'number', 'value' => 2 }, false]
+   puts var.to_bashon('var')
+
+function var { echo var_0 var_1 var_2; } ; function var_0 { echo one; };function var_1 { case "$1" in value) echo var_1_value;; type) echo var_1_type;; '') echo value type;; esac; }; function var_1_value { echo 2; };function var_1_type { echo number; };function var_2 { return 1; }
+
+   $ for elfun $(var)
+   > do
+   >    $elfun
+
+A deeply nested hash:
+
+   cfg = { "prod" => { "db" => { "host" => "dbhost001",
+                                 "port" => 3389 },
+                       "url" => "https://api/",
+                       "log" => { "file" => "/var/log/app.log",
+                                  "debug" => false },
+                       "notify" => [ "www", "ops" ] },
+           "qa" => { "db" => { "host" => "qa02",
+                               "port" => 18009 },
+                     "url" => "https://qa02:18008/v2/",
+                     "log" => { "file" => "~qa/build9/log/app.log",
+                                "debug" => true },
+                     "notify" => [ "build", "test" ] }
+          }
+   puts cfg.to_bashon('cfg')
+
+function cfg { case "$1" in prod) echo cfg_prod;; qa) echo cfg_qa;; '') echo prod qa;; esac; }; function cfg_prod { case "$1" in notify) echo cfg_prod_notify;; log) echo cfg_prod_log;; url) echo cfg_prod_url;; db) echo cfg_prod_db;; '') echo notify log url db;; esac; }; function cfg_prod_notify { echo cfg_prod_notify_0 cfg_prod_notify_1; } ; function cfg_prod_notify_0 { echo www; };function cfg_prod_notify_1 { echo ops; };function cfg_prod_log { case "$1" in debug) echo cfg_prod_log_debug;; file) echo cfg_prod_log_file;; '') echo debug file;; esac; }; function cfg_prod_log_debug { return 1; };function cfg_prod_log_file { echo /var/log/app.log; };function cfg_prod_url { echo https://api/; };function cfg_prod_db { case "$1" in port) echo cfg_prod_db_port;; host) echo cfg_prod_db_host;; '') echo port host;; esac; }; function cfg_prod_db_port { echo 3389; };function cfg_prod_db_host { echo dbhost001; };function cfg_qa { case "$1" in notify) echo cfg_qa_notify;; log) echo cfg_qa_log;; url) echo cfg_qa_url;; db) echo cfg_qa_db;; '') echo notify log url db;; esac; }; function cfg_qa_notify { echo cfg_qa_notify_0 cfg_qa_notify_1; } ; function cfg_qa_notify_0 { echo build; };function cfg_qa_notify_1 { echo test; };function cfg_qa_log { case "$1" in debug) echo cfg_qa_log_debug;; file) echo cfg_qa_log_file;; '') echo debug file;; esac; }; function cfg_qa_log_debug { return 0; };function cfg_qa_log_file { echo ~qa/build9/log/app.log; };function cfg_qa_url { echo https://qa02:18008/v2/; };function cfg_qa_db { case "$1" in port) echo cfg_qa_db_port;; host) echo cfg_qa_db_host;; '') echo port host;; esac; }; function cfg_qa_db_port { echo 18009; };function cfg_qa_db_host { echo qa02; }
+
+   $ env=prod
+   $ curl $($(cfg $env) url)/report.sql | \
+   > mysql -h $($($(cfg $env) db) host) -p $($($(cfg $env) db) port) | \
+   > tee -a $($($(cfg $env) log) file) | \
+   > mailx -s "Report" `for m in $($($(cfg $env) notify)); do echo $($m); done`
+   $ $($($(cfg $env) log) debug) && echo `date` `whoami`>>$($($(cfg $env) log) file)
+
+=head1 BUGS
+
+Right now string serialization makes no attempt to quote strings. If the
+string contains a shell metacharacter, results can be unexpected. In fact,
+results can be a bit unexpected anyway. I've tried different quoting schemes
+and they all get real ugly real fast. In fact, things can be unexpected with
+just a run of spaces or a newline.
+
+You can't have a space in hash keys, but there's no helpful error message
+until you eval the result. The problem is that it's really hard to return a
+list of things that is useful for a 'for' loop where the list of things might
+contain a space.
+
+There's no good way of determining the "type" of something you encounter. You
+can test the output of a function, and if each of the words in it is itself a
+function, it's an array. However, if they're not, there's no way to
+distinguish between a string that has multiple words and a list of hash keys.
+
+Possibly arrays should work exactly like hashes, returning a list of indexes
+instead of keys. Right now you can't access an array by index at all.
+
+=head1 NOTES
+
+Why not use variables instead of functions? I went down that road, but the
+problem is that even bash 4, with its associative arrays, doesn't provide
+enough flexibility to do nested structures, and you run into all kinds of
+quoting difficulties and whatnot when you try to serialize to variables.
+
+For example, you can serialize an array of strings in bash like this:
+
+   declare -a var
+   var=([0]=one [1]=two [2]=three)
+
+But what if the values in the array are themselves arrays? Or associative
+arrays? Bash can't handle that. Also, all your quoting has to be right in
+order for that assignment to work, which is really difficult to get right
+in a general solution with the possibility of arbitrarily nested structures.
+
+Also, I'll note that arrays and associative arrays aren't really that
+convenient in bash. I'm not sure that $(var key1) is really any harder to use
+or read than ${var[key1]}.
+
+So, I went with functions, and for consistency's sake serialized everything as
+functions. That way you always know that when you get something back from
+fetching a hash entry, you have to call it, there's no ambiguity about whether
+it's a raw value or a hash.
+
+There's another approach to this, which is to serialize everything into some
+kind of text structure and then provide bash functions/commands to operate on
+this blob of text. For example:
+
+   puts var.to_json
+
+   var='{"key1":"val1","key2":["val2one","val2two"],"key3":{"subkey1":1,"subkey2":2}}'
+
+   $ json_get "$var" key1
+   val1
+   $ json_get "$var" key2
+   ["val2one","val2two"]
+   $ json_get "$var" key2 0
+   val2one
+   $ json_get "$var" key3
+   {"subkey1":1,"subkey2":2}
+   $ json_keys "$var"
+   key1
+   key2
+   key3
+   $ json_keys "$var" key3
+   subkey1
+   subkey2
+   $ json_keys "$var" key3 subkey2
+   2
+
+This is viable but I think it's less convenient to use from bash.
+
+=head1 AUTHOR
+
+Jeremy Brinkley, E<lt>jbrinkley@evernote.comE<gt>
+
+=cut
+EOF
+end
+
+class Object
+   include BashOn
+   def to_bashon(*name)
+      if name.empty?
+         "#{self.to_s}"
+      else
+         "function #{name_key(name)} { echo #{self.to_bashon()}; }"
+      end
+   end
+end
+
+class TrueClass
+   include BashOn
+   def to_bashon(*name)
+      if name.empty?
+         "true"
+      else
+         "function #{name_key(name)} { return 0; }"
+      end
+   end
+end
+
+class FalseClass
+   include BashOn
+   def to_bashon(*name)
+      if name.empty?
+         "false"
+      else
+         "function #{name_key(name)} { return 1; }"
+      end
+   end
+end
+
+class NilClass
+   include BashOn
+   def to_bashon(*name)
+      if name.empty?
+         ""
+      else
+         "unset #{name_key(name)}"
+      end
+   end
+end
+
+class String
+   include BashOn
+
+   def bq
+      self.gsub("'", "'\''")
+   end
+
+   def to_bashon(*name)
+      if name.empty?
+         self
+      else
+         "function #{name_key(name)} { echo '#{self.to_bashon.bq}'; }"
+      end
+   end
+end
+
+# Enumerable?
+class Array
+   include BashOn
+   def to_bashon(*name)
+      "function #{name_key(name)} { echo " +
+         (0 .. (self.nitems-1)).map { |i|
+         name_key(name + [i.to_s]) }.join(' ') + "; } " +
+         (self.empty? ? ' ' : '; ') +
+         (0 .. (self.nitems-1)).map { |i|
+         self[i].to_bashon(*(name + [i.to_s])) }.join(';')
+   end
+end
+
+class Hash
+   include BashOn
+   def to_bashon(*name)
+      "function #{name_key(name)} { case \"$1\" in " +
+         self.map { |k, v| "#{k}) echo '#{name_key(name + [k])}';;" }.join(' ') +
+         " '') echo '#{self.keys.join(' ')}';;" +
+         " esac; }" + (self.empty? ? ' ' : '; ') +
+         self.map { |k, v| self[k].to_bashon(*(name + [k])) }.join(';')
+   end
+end

data/lib/longopt.rb

@@ -0,0 +1,239 @@
+#!ruby
+# /* Copyright 2013 Proofpoint, Inc. All rights reserved.
+#    Copyright 2014 Evernote Corp. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# */
+
+require 'getoptlong'
+
+class Longopt < Hash
+
+   attr_accessor :optspec
+
+   def Longopt.new_with_args(argv, *optspecs)
+      obj = Longopt.allocate
+      obj.getopts_with_argv(argv, *optspecs)
+      obj
+   end
+
+   def getopts_with_args(argv, *optspeclist)
+      saveargv = ARGV.dup
+      # produces warning
+      ARGV.replace(argv)
+      getopts(*optspeclist)
+      ARGV.replace(saveargv)
+      self
+   end
+
+   def Longopt.default(opth)
+      obj = Longopt.allocate
+      obj.merge(opth)
+   end
+
+   def initialize(*optspecs)
+      getopts(*optspecs)
+   end
+
+   def getopts(*optspecs)
+      @optspec = { }
+
+      if optspecs.size == 1 and optspecs[0].respond_to? :to_ary
+         optspecs = optspecs[0]
+      end
+
+      optspecs.each do |optspec|
+         if m = /^([\w_\-]+)([=:!+].*)/.match(optspec)
+            opt = m[1]
+            @optspec[opt] = { }
+
+            act, typ, collect_typ = m[2].split('')
+
+            case act
+
+            when '='
+               @optspec[opt]['gol-argument-type'] =
+                  GetoptLong::REQUIRED_ARGUMENT
+               @optspec[opt]['type-letter'] = typ
+               @optspec[opt]['collection-type'] = collect_typ
+
+            when ':'
+               @optspec[opt]['gol-argument-type'] =
+                  GetoptLong::OPTIONAL_ARGUMENT
+               @optspec[opt]['type-letter'] = typ
+               @optspec[opt]['collection-type'] = collect_typ
+
+            when '!'
+               @optspec[opt]['gol-argument-type'] = GetoptLong::NO_ARGUMENT
+               @optspec[opt]['type-letter'] = 'b'
+               @optspec['no' + opt] = { }
+               @optspec['no' + opt]['gol-argument-type'] =
+                  GetoptLong::NO_ARGUMENT
+
+            when '+'
+               @optspec[opt]['gol-argument-type'] = GetoptLong::NO_ARGUMENT
+               @optspec[opt]['type-letter'] = 'a'
+
+            end
+         else
+            @optspec[optspec] = { }
+            @optspec[optspec]['gol-argument-type'] = GetoptLong::NO_ARGUMENT
+            @optspec[optspec]['type-letter'] = 'b'
+         end
+      end
+
+      gol_arguments = @optspec.map { |opt, optspec|
+         ['--' + opt,
+          optspec['gol-argument-type']]
+      }
+
+      GetoptLong.new(*gol_arguments).each do |k, v|
+         k = k.sub(/^--/, '')
+
+         case k
+
+         when *booleans
+            self[k] = true
+
+         when *nobooleans
+            self[k[2..-1]] = false
+
+         when *simples
+            self[k] = simple_value(k, v)
+
+         when *lists
+            self[k] = [ ] unless key? k
+            self[k].push(simple_value(k, v))
+
+         when *mappings
+            self[k] = { } unless key? k
+            mkey, mvalue = v.split(/=/, 2)
+            self[k][mkey] = simple_value(k, mvalue)
+
+         end
+      end
+
+   end
+
+   def simple_value(opt, optarg)
+      case @optspec[opt]['type-letter']
+      when 's'
+         optarg
+      when 'i'
+         Integer(optarg)
+      when 'f'
+         Float(optarg)
+      when 'a'
+         if key? opt
+            rv = self[opt] + 1
+         else
+            rv = 1
+         end
+         rv
+      else
+         nil
+      end
+   end
+
+   def booleans
+      @optspec.reject { |k, v| v['type-letter'] != 'b' }.keys
+   end
+
+   def nobooleans
+      @optspec.reject { |k, v| v['type-letter'] != 'b' }.keys.map { |el| 'no' + el }
+   end
+
+   def simples
+      @optspec.reject { |k, v| ! v['collection-type'].nil? ||
+                              v['type-letter'].nil? ||
+                              v['type-letter'] == 'b' }.keys
+   end
+
+   def lists
+      @optspec.reject { |k, v| v['collection-type'] != '@' }.keys
+   end
+
+   def mappings
+      @optspec.reject { |k, v| v['collection-type'] != '%' }.keys
+   end
+
+   @@manpage = <<'EOF'
+=head1 NAME
+
+Longopt - Convenience class similar to Perl Getopt::Long
+
+=head1 SYNOPSIS
+
+   require 'longoopt'
+
+   opt = Longopt.new('verbose', 'force!', 'logfile=s',
+                     'define=s%', 'user=s@')
+
+   print "Verbose enabled" if opt['verbose']
+
+   unlink(filefoo) if opt['force']
+
+   File.open(opt['logfile'], 'w') { |fh| fh << "Log message" }
+
+   opt['user'].each { |user| notify_user(user) }
+
+   opt['define'].each { |key, value| puts "#{key} = #{value}" }
+
+=head1 DESCRIPTION
+
+The Longopt class wraps GetoptLong so that you can use option specifiers
+similar to the Perl Getopt::Long module.
+
+Longopt is a Hash subclass.
+
+=head2 Class Methods
+
+=over 4
+
+=item new(*optspecs)
+
+Parse ARGV for options and set options according to provided optspecs.
+
+=item new_with_args(args, *optspecs)
+
+Like new(), but use provided arguments rather than ARGV.
+
+=item default(opthash)
+
+Create a Longopt object using the provided default option values in the
+opthash. Use getopts(), below, to parse arguments.
+
+=back
+
+=head2 Object Methods
+
+=item getopts(*optspecs)
+
+Parse ARGV to set option values according to provided optspecs.
+
+=item getopts_with_args(args, *optspecs)
+
+Parse args to set option values according to provided optspecs.
+
+=back
+
+=head1 AUTHOR
+
+Jeremy Brinkley, E<lt>jbrinkley@evernote.comE<gt>
+
+=cut
+
+EOF
+
+end
+

data/lib/optconfig/version.rb

@@ -0,0 +1,5 @@
+class Optconfig
+
+    VERSION = '1.5.3'
+
+end

data/lib/optconfig.rb

@@ -0,0 +1,182 @@
+#!ruby
+# /* Copyright 2013 Proofpoint, Inc. All rights reserved.
+#    Copyright 2014 Evernote Corp. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# */
+
+# = NAME
+#
+# Optconfig - Parse options and config files
+#
+# = DESCRIPTION
+#
+# This module implements the Optconfig standardized approach to
+# command-line option parsing and JSON-based configuration file
+# interpretation. See the reference documentation in the
+# Optconfig master distribution for details.
+#
+
+require 'rubygems'
+require 'longopt'
+require 'json'
+
+class Optconfig < Hash
+
+    require 'optconfig/version'
+
+   attr_accessor :domain, :optspec, :config, :default
+
+   def add_standard_opts(submitted_optspec)
+      optspec = submitted_optspec
+      standard_opts = {
+         'config=s' => nil,
+         'debug+' => 0,
+         'verbose+' => 0,
+         'version' => false,
+         'help' => false,
+         'dry-run!' => false }
+      standard_opts.each_pair do |opt, defval|
+         if ! optspec.has_key? opt
+            optspec[opt] = defval
+         end
+      end
+      optspec
+   end
+
+   def initialize(domain, submitted_optspec, version=nil)
+      @domain = domain
+      @optspec = add_standard_opts(submitted_optspec)
+       @caller_version = version || $VERSION || 'Unknown version'
+
+      submitted_optspec.each_pair do |optspec, val|
+         opt, dummy = optspec.split(/[\=\+\!]/, 2)
+         self[opt] = val
+      end
+
+       cfgfilepath = [ '/usr/local/etc/' + domain + '.conf',
+           '/etc/' + domain + '.conf' ]
+
+      if ENV.has_key? 'HOME' and ! ENV['HOME'].nil?
+         cfgfilepath.unshift(ENV['HOME'] + '/.' + domain)
+      end
+      @config = nil
+
+       cmdlineopt = Longopt.new(optspec.keys)
+
+      if cmdlineopt.has_key? 'config'
+         @config = cmdlineopt['config']
+         raise "File not found: #{cmdlineopt['config']}" unless
+            File.exist? cmdlineopt['config']
+         read_config(cmdlineopt['config'])
+      else
+         cfgfilepath.each do |file|
+            if File.readable? file
+               @config = file
+               read_config(file)
+               break
+            end
+         end
+      end
+
+      cmdlineopt.each_pair do |opt, val|
+         merge_cmdlineopt(opt, val)
+      end
+
+      if self.has_key? 'version' and self['version']
+          puts @caller_version
+          Process.exit(0)
+      end
+
+       if self.has_key? 'help' and self['help']
+          help_pattern = /(?:^=head1 +SYNOPSIS|^# *=+ *SYNOPSIS)(.*?)(?:^=head1|^# *=+)/m
+          myscript = File.expand_path($0)
+          begin
+              script_text = File.open(myscript, 'r') { |fh| fh.read }
+              if /This file was generated by RubyGems/.match script_text
+                  # Well, thank you RubyGems. Now I have to guess where
+                  # my code ended up.
+                  #
+                  # The ruby gems wrapper for these scripts has some
+                  # special way of restricting versions here; I'm hoping
+                  # that since that has been done (and I no longer have
+                  # access to the special first argument that overrides
+                  # the version) that the fact that the 'gem' call has
+                  # already been called with that version will help
+                  # the following work correctly. Because there's no
+                  # real other alternative.
+                  #
+                  # This 'parsing' is really a load of crap. Sure hope
+                  # Rubygems never changes anything.
+                  # -jdb/20141010
+                  if m = /^\s*load +(.*)$/.match(script_text)
+                      script_file = eval("version = nil\n" + m[1])
+                      script_text = File.open(script_file, 'r') { |fh| fh.read }
+                  end
+              end
+              m = help_pattern.match(script_text)
+              if m
+                  puts m[1].gsub(/^# ?/m, '').strip
+              else
+                  puts 'No help'
+              end
+          rescue Errno::ENOENT
+              puts "No help (could not search #{myscript})"
+          end
+          Process.exit(0)
+      end
+   end
+
+   def read_config(file)
+      fileconfig = File.open(file) { |fh| JSON.load(fh) }
+      fileconfig.each_pair do |opt, val|
+         self[opt] = val
+      end
+   end
+
+   def merge_cmdlineopt(opt, val)
+      if self.has_key? opt
+         if self[opt].respond_to? :keys
+            if val.respond_to? :keys
+               # Both hashes, merge
+               val.each_pair { |k, v| self[opt][k] = v }
+            else
+               self[opt] = val
+            end
+         elsif self[opt].respond_to? :unshift
+            if val.respond_to? :each and val.respond_to? :reverse
+               val.reverse.each { |v| self[opt].unshift(v) }
+            else
+               self[opt] = val
+            end
+         else
+            self[opt] = val
+         end
+      else
+         self[opt] = val
+      end
+
+      self[opt]
+   end
+
+   def vrb(level, *msg)
+      puts msg.join("\n") if self['verbose'] >= level
+   end
+
+   def dbg(level, *msg)
+      if self['debug'] >= level
+         puts "DBG(#{@domain}): " + msg.join("DBG(#{@domain}):    ")
+      end
+   end
+
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: noms-optconfig
+version: !ruby/object:Gem::Version
+  version: 1.5.3
+  prerelease: 
+platform: ruby
+authors:
+- Jeremy Brinkley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+description: Optconfig presents a standardized way to parse configuration files and
+  command-line arguments
+email:
+- jbrinkley@evernote.com
+executables:
+- ruby-showconfig
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/optconfig.rb
+- lib/optconfig/version.rb
+- lib/longopt.rb
+- lib/bashon.rb
+- bin/ruby-showconfig
+- bin/optconfig.sh
+- bin/bash-showconfig
+homepage: http://github.com/evernote/optconfig
+licenses:
+- Apache-2
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Parse commmand-line options and config files
+test_files: []