RubyGems - ursm-ditz - Versions diffs - 0.4 → 0.5 - Mend

ursm-ditz 0.4 → 0.5

Files changed (50) hide show

data/Changelog +15 -0
data/INSTALL +20 -0
data/LICENSE +674 -0
data/Manifest.txt +40 -0
data/PLUGINS.txt +140 -0
data/README.txt +43 -27
data/Rakefile +36 -3
data/ReleaseNotes +6 -0
data/bin/ditz +49 -63
data/contrib/completion/ditz.bash +25 -9
data/lib/ditz.rb +52 -7
data/lib/ditz/file-storage.rb +54 -0
data/lib/{hook.rb → ditz/hook.rb} +1 -1
data/lib/{html.rb → ditz/html.rb} +42 -4
data/lib/{lowline.rb → ditz/lowline.rb} +31 -11
data/lib/{model-objects.rb → ditz/model-objects.rb} +53 -21
data/lib/ditz/model.rb +321 -0
data/lib/{operator.rb → ditz/operator.rb} +122 -67
data/lib/ditz/plugins/git-sync.rb +83 -0
data/lib/{plugins → ditz/plugins}/git.rb +57 -18
data/lib/ditz/plugins/issue-claiming.rb +174 -0
data/lib/ditz/plugins/issue-labeling.rb +161 -0
data/lib/{util.rb → ditz/util.rb} +4 -0
data/lib/{view.rb → ditz/view.rb} +0 -0
data/lib/{views.rb → ditz/views.rb} +7 -4
data/man/{ditz.1 → man1/ditz.1} +1 -1
data/setup.rb +1585 -0
data/share/ditz/blue-check.png +0 -0
data/{lib → share/ditz}/component.rhtml +7 -5
data/share/ditz/green-bar.png +0 -0
data/share/ditz/green-check.png +0 -0
data/share/ditz/index.rhtml +130 -0
data/share/ditz/issue.rhtml +119 -0
data/share/ditz/issue_table.rhtml +28 -0
data/share/ditz/red-check.png +0 -0
data/share/ditz/release.rhtml +98 -0
data/share/ditz/style.css +226 -0
data/share/ditz/unassigned.rhtml +23 -0
data/share/ditz/yellow-bar.png +0 -0
metadata +50 -28
data/lib/index.rhtml +0 -113
data/lib/issue.rhtml +0 -111
data/lib/issue_table.rhtml +0 -33
data/lib/model.rb +0 -208
data/lib/plugins/issue-claiming.rb +0 -92
data/lib/release.rhtml +0 -69
data/lib/style.css +0 -127
data/lib/trollop.rb +0 -518
data/lib/unassigned.rhtml +0 -31
data/lib/vendor/yaml_waml.rb +0 -28

data/lib/plugins/issue-claiming.rb DELETED

@@ -1,92 +0,0 @@
-module Ditz
-class Issue
-  field :claimer, :ask => false
-  def claim who, comment, force=false
-    raise Error, "already claimed by #{claimer}" if claimer && !force
-    log "issue claimed", who, comment
-    self.claimer = who
-  end
-  def unclaim who, comment, force=false
-    raise Error, "not claimed" unless claimer
-    raise Error, "can only be unclaimed by #{claimer}" unless claimer == who || force
-    if claimer == who
-      log "issue unclaimed", who, comment
-    else
-      log "unassigned from #{claimer}", who, comment
-    end
-    self.claimer = nil
-  end
-  def claimed?; claimer end
-  def unclaimed?; !claimed? end
-end
-class ScreenView
-  add_to_view :issue_summary do |issue, config|
-    " Claimed by: #{issue.claimer || 'none'}\n"
-  end
-end
-class HtmlView
-  add_to_view :issue_summary do |issue, config|
-    next unless issue.git_branch
-    [<<EOS, { :issue => issue, :url_prefix => config.git_branch_url_prefix }]
-<tr>
-  <td class='attrname'>Claimed by:</td>
-  <td class='attrval'>h(issue.claimer) %></td>
-</tr>
-EOS
-  end
-end
-class Operator
-  operation :claim, "Claim an issue for yourself", :issue do
-    opt :force, "Claim this issue even if someone else has claimed it", :default => false
-  end
-  def claim project, config, opts, issue
-    puts "Claiming issue #{issue.name}: #{issue.title}."
-    comment = ask_multiline "Comments" unless $opts[:no_comment]
-    issue.claim config.user, comment, opts[:force]
-    puts "Issue #{issue.name} marked as claimed by #{config.user}"
-  end
-  operation :unclaim, "Unclaim a claimed issue", :issue do
-    opt :force, "Unclaim this issue even if it's claimed by someone else", :default => false
-  end
-  def unclaim project, config, opts, issue
-    puts "Unclaiming issue #{issue.name}: #{issue.title}."
-    comment = ask_multiline "Comments" unless $opts[:no_comment]
-    issue.unclaim config.user, comment, opts[:force]
-    puts "Issue #{issue.name} marked as unclaimed."
-  end
-  operation :claimed, "Show all issues claimed by you" do
-    opt :all, "Show all issues, not just open ones"
-  end
-  def claimed project, config, opts
-    puts "#{opts[:all] ? "All" : "Open"} issues claimed by you:"
-    issues = project.issues.select { |i| i.claimer == config.user && (opts[:all] || i.open?) }
-    if issues.empty?
-      puts "No issues."
-    else
-      print_todo_list_by_release_for project, issues
-    end
-  end
-  operation :unclaimed, "Show all unclaimed issues" do
-    opt :all, "Show all issues, not just open ones"
-  end
-  def unclaimed project, config, opts
-    puts "Unclaimed#{opts[:all] ? "" : ", open"} issues:"
-    issues = project.issues.select { |i| i.claimer.nil? && (opts[:all] || i.open?) }
-    if issues.empty?
-      puts "No issues."
-    else
-      print_todo_list_by_release_for project, issues
-    end
-  end
-end
-end

data/lib/release.rhtml DELETED

@@ -1,69 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<title><%= project.name %> release <%= release.name %></title>
-<meta http-equiv="Content-Type" content="text/html; charset=utf8" />
-<link rel="stylesheet" href="style.css" type="text/css" />
-</head>
-<body>
-<div><%= link_to "index", "&laquo; #{project.name} project page" %></div>
-<h1><%= project.name %> release <%= release.name %></h1>
-<table>
-  <tr>
-    <td class="attrname">Status:</td>
-    <td class="attrval"><%= release.status %></td>
-  </tr>
-  <% if release.released? %>
-    <tr>
-      <td class="attrname">Release time:</td>
-      <td class="attrval"><%= release.release_time %></td>
-    </tr>
-  <% end %>
-  <tr>
-    <%
-      num_done = issues.count_of { |i| i.closed? }
-      pct_done = issues.size == 0 ? 100 : (100.0 * num_done / issues.size)
-    %>
-    <td class="attrname">Completion:</td>
-    <td class="attrval"><%= sprintf "%.0f%%", pct_done %></td>
-  </tr>
-</table>
-<h2>Issues</h2>
-<% if issues.empty? %>
-  <p>No issues assigned to this release.</p>
-<% else %>
-  <%= render "issue_table", :show_component => false, :show_release => false %>
-<% end %>
-<h2>Release log</h2>
-<table>
-<% release.log_events.each_with_index do |(time, who, what, comment), i| %>
-<% if i % 2 == 0 %>
-  <tr class="logentryeven">
-<% else %>
-  <tr class="logentryodd">
-<% end %>
-  <td class="logtime"><%=h time %></td>
-  <td class="logwho"><%=obscured_email who %></td>
-  <td class="logwhat"><%=h what %></td>
-  </tr>
-  <tr><td colspan="3" class="logcomment">
-    <% if comment.empty? %>
-    <% else %>
-      <%= link_issue_names project, p(comment) %>
-    <% end %>
-  </td></tr>
-<% end %>
-</table>
-<p class="footer">Generated by <a
-href="http://ditz.rubyforge.org/">ditz</a>.</p>
-</body>
-</html>

data/lib/style.css DELETED

@@ -1,127 +0,0 @@
-body {
-	background: white;
-	color: #202020;
-	margin-bottom: 2em;
-	margin-left: auto;
-	margin-right: auto;
-	width: 90%;
-}
-div.wrapper {
-}
-div.footer {
-}
-a, a:visited {
-	border-bottom: 1px dotted #03c;
-	background: inherit;
-	text-decoration: none;
-  color: #03c;
-}
-ul {
-  list-style-type: none;
-  padding: 0;
-}
-p {
-  width: 40em;
-}
-.dimmed {
-  color: #bbb;
-}
-div.on-the-left {
-  float: left;
-  width: 39%;
-}
-div.on-the-right {
-  float: right;
-  width: 59%;
-}
-table {
-  border-style: none;
-  border-spacing: 0;
-}
-td {
-  border-width: 0;
-  border-style: none;
-  padding-right: 0.5em;
-  padding-left: 0.5em;
-}
-tr {
-  padding-bottom: 5em;
-}
-h1 {
-  padding: 0.2em;
-  margin-left: -1em;
-  margin-right: 1em;
-  background: #abc;
-}
-.attrname {
-  text-align: right;
-}
-.issuestatus_closed {
-  background-color: #afa;
-  text-align: center;
-}
-.issuestatus_in_progress {
-  background-color: #ffa;
-  text-align: center;
-}
-.issuestatus_paused {
-  background-color: #ffa;
-  text-align: center;
-}
-.issuestatus_unstarted {
-  background-color: #faa;
-  text-align: center;
-}
-.issuestatus_closed a {
-  color: #202020;
-}
-.issuestatus_in_progress a {
-  color: #202020;
-}
-.issuestatus_paused a {
-  color: #202020;
-}
-.issuestatus_unstarted a {
-  color: #202020;
-}
-.logwhat {
-}
-.logentryeven {
-  background: #eee;
-}
-.logentryodd {
-  background: #eee;
-}
-.logcomment {
-  padding-left: 3em;
-}
-p.footer {
-  font-size: small;
-}

data/lib/trollop.rb DELETED

@@ -1,518 +0,0 @@
-## lib/trollop.rb -- trollop command-line processing library
-## Author::    William Morgan (mailto: wmorgan-trollop@masanjin.net)
-## Copyright:: Copyright 2007 William Morgan
-## License::   GNU GPL version 2
-module Trollop
-VERSION = "1.8.2"
-## Thrown by Parser in the event of a commandline error. Not needed if
-## you're using the Trollop::options entry.
-class CommandlineError < StandardError; end
-## Thrown by Parser if the user passes in '-h' or '--help'. Handled
-## automatically by Trollop#options.
-class HelpNeeded < StandardError; end
-## Thrown by Parser if the user passes in '-h' or '--version'. Handled
-## automatically by Trollop#options.
-class VersionNeeded < StandardError; end
-## Regex for floating point numbers
-FLOAT_RE = /^-?((\d+(\.\d+)?)|(\.\d+))$/
-## Regex for parameters
-PARAM_RE = /^-(-|\.$|[^\d\.])/
-## The commandline parser. In typical usage, the methods in this class
-## will be handled internally by Trollop#options, in which case only the
-## methods #opt, #banner and #version, #depends, and #conflicts will
-## typically be called.
-class Parser
-  ## The set of values specifiable as the :type parameter to #opt.
-  TYPES = [:flag, :boolean, :bool, :int, :integer, :string, :double, :float]
-  ## :nodoc:
-  INVALID_SHORT_ARG_REGEX = /[\d-]/
-  ## The values from the commandline that were not interpreted by #parse.
-  attr_reader :leftovers
-  ## The complete configuration hashes for each option. (Mainly useful
-  ## for testing.)
-  attr_reader :specs
-  ## Initializes the parser, and instance-evaluates any block given.
-  def initialize *a, &b
-    @version = nil
-    @leftovers = []
-    @specs = {}
-    @long = {}
-    @short = {}
-    @order = []
-    @constraints = []
-    @stop_words = []
-    @stop_on_unknown = false
-    #instance_eval(&b) if b # can't take arguments
-    cloaker(&b).bind(self).call(*a) if b
-  end
-  ## Add an option. 'name' is the argument name, a unique identifier
-  ## for the option that you will use internally. 'desc' a string
-  ## description which will be displayed in help messages. Takes the
-  ## following optional arguments:
-  ##
-  ## * :long: Specify the long form of the argument, i.e. the form
-  ##   with two dashes. If unspecified, will be automatically derived
-  ##   based on the argument name.
-  ## * :short: Specify the short form of the argument, i.e. the form
-  ##   with one dash. If unspecified, will be automatically derived
-  ##   based on the argument name.
-  ## * :type: Require that the argument take a parameter of type
-  ##   'type'. Can by any member of the TYPES constant or a
-  ##   corresponding class (e.g. Integer for :int). If unset, the
-  ##   default argument type is :flag, meaning the argument does not
-  ##   take a parameter. Not necessary if :default: is specified.
-  ## * :default: Set the default value for an argument. Without a
-  ##   default value, the hash returned by #parse (and thus
-  ##   Trollop#options) will not contain the argument unless it is
-  ##   given on the commandline. The argument type is derived
-  ##   automatically from the class of the default value given, if
-  ##   any. Specifying a :flag argument on the commandline whose
-  ##   default value is true will change its value to false.
-  ## * :required: if set to true, the argument must be provided on the
-  ##   commandline.
-  def opt name, desc="", opts={}
-    raise ArgumentError, "you already have an argument named '#{name}'" if @specs.member? name
-    ## fill in :type
-    opts[:type] =
-      case opts[:type]
-      when :flag, :boolean, :bool; :flag
-      when :int, :integer; :int
-      when :string; :string
-      when :double, :float; :float
-      when Class
-        case opts[:type].to_s # sigh... there must be a better way to do this
-        when 'TrueClass', 'FalseClass'; :flag
-        when 'String'; :string
-        when 'Integer'; :int
-        when 'Float'; :float
-        else
-          raise ArgumentError, "unsupported argument type '#{opts[:type].class.name}'"
-        end
-      when nil; nil
-      else
-        raise ArgumentError, "unsupported argument type '#{opts[:type]}'" unless TYPES.include?(opts[:type])
-      end
-    type_from_default =
-      case opts[:default]
-      when Integer; :int
-      when Numeric; :float
-      when TrueClass, FalseClass; :flag
-      when String; :string
-      when nil; nil
-      else
-        raise ArgumentError, "unsupported argument type '#{opts[:default].class.name}'"
-      end
-    raise ArgumentError, ":type specification and default type don't match" if opts[:type] && type_from_default && opts[:type] != type_from_default
-    opts[:type] = (opts[:type] || type_from_default || :flag)
-    ## fill in :long
-    opts[:long] = opts[:long] ? opts[:long].to_s : name.to_s.gsub("_", "-")
-    opts[:long] =
-      case opts[:long]
-      when /^--([^-].*)$/
-        $1
-      when /^[^-]/
-        opts[:long]
-      else
-        raise ArgumentError, "invalid long option name #{opts[:long].inspect}"
-      end
-    raise ArgumentError, "long option name #{opts[:long].inspect} is already taken; please specify a (different) :long" if @long[opts[:long]]
-    ## fill in :short
-    opts[:short] = opts[:short].to_s if opts[:short] unless opts[:short] == :none
-    opts[:short] =
-      case opts[:short]
-      when nil
-        c = opts[:long].split(//).find { |c| c !~ INVALID_SHORT_ARG_REGEX && !@short.member?(c) }
-        raise ArgumentError, "can't generate a short option name for #{opts[:long].inspect}: out of unique characters" unless c
-        c
-      when /^-(.)$/
-        $1
-      when /^.$/
-        opts[:short]
-      when :none
-        nil
-      else
-        raise ArgumentError, "invalid short option name '#{opts[:short].inspect}'"
-      end
-    if opts[:short]
-      raise ArgumentError, "short option name #{opts[:short].inspect} is already taken; please specify a (different) :short" if @short[opts[:short]]
-      raise ArgumentError, "a short option name can't be a number or a dash" if opts[:short] =~ INVALID_SHORT_ARG_REGEX
-    end
-    ## fill in :default for flags
-    opts[:default] = false if opts[:type] == :flag && opts[:default].nil?
-    opts[:desc] ||= desc
-    @long[opts[:long]] = name
-    @short[opts[:short]] = name if opts[:short]
-    @specs[name] = opts
-    @order << [:opt, name]
-  end
-  ## Sets the version string. If set, the user can request the version
-  ## on the commandline. Should be of the form "<program name>
-  ## <version number>".
-  def version s=nil; @version = s if s; @version end
-  ## Adds text to the help display.
-  def banner s; @order << [:text, s] end
-  alias :text :banner
-  ## Marks two (or more!) options as requiring each other. Only handles
-  ## undirected (i.e., mutual) dependencies. Directed dependencies are
-  ## better modeled with Trollop::die.
-  def depends *syms
-    syms.each { |sym| raise ArgumentError, "unknown option '#{sym}'" unless @specs[sym] }
-    @constraints << [:depends, syms]
-  end
-  ## Marks two (or more!) options as conflicting.
-  def conflicts *syms
-    syms.each { |sym| raise ArgumentError, "unknown option '#{sym}'" unless @specs[sym] }
-    @constraints << [:conflicts, syms]
-  end
-  ## Defines a set of words which cause parsing to terminate when encountered,
-  ## such that any options to the left of the word are parsed as usual, and
-  ## options to the right of the word are left intact.
-  ##
-  ## A typical use case would be for subcommand support, where these would be
-  ## set to the list of subcommands. A subsequent Trollop invocation would
-  ## then be used to parse subcommand options.
-  def stop_on *words
-    @stop_words = [*words].flatten
-  end
-  ## Similar to stop_on, but stops on any unknown word when encountered (unless
-  ## it is a parameter for an argument).
-  def stop_on_unknown
-    @stop_on_unknown = true
-  end
-  ## yield successive arg, parameter pairs
-  def each_arg args # :nodoc:
-    remains = []
-    i = 0
-    until i >= args.length
-      if @stop_words.member? args[i]
-        remains += args[i .. -1]
-        return remains
-      end
-      case args[i]
-      when /^--$/ # arg terminator
-        remains += args[(i + 1) .. -1]
-        return remains
-      when /^--(\S+?)=(\S+)$/ # long argument with equals
-        yield "--#{$1}", $2
-        i += 1
-      when /^--(\S+)$/ # long argument
-        if args[i + 1] && args[i + 1] !~ PARAM_RE && !@stop_words.member?(args[i + 1])
-          take_an_argument = yield args[i], args[i + 1]
-          unless take_an_argument
-            if @stop_on_unknown
-              remains += args[i + 1 .. -1]
-              return remains
-            else
-              remains << args[i + 1]
-            end
-          end
-          i += 2
-        else # long argument no parameter
-          yield args[i], nil
-          i += 1
-        end
-      when /^-(\S+)$/ # one or more short arguments
-        shortargs = $1.split(//)
-        shortargs.each_with_index do |a, j|
-          if j == (shortargs.length - 1) && args[i + 1] && args[i + 1] !~ PARAM_RE && !@stop_words.member?(args[i + 1])
-            take_an_argument = yield "-#{a}", args[i + 1]
-            unless take_an_argument
-              if @stop_on_unknown
-                remains += args[i + 1 .. -1]
-                return remains
-              else
-                remains << args[i + 1]
-              end
-            end
-            i += 1 # once more below
-          else
-            yield "-#{a}", nil
-          end
-        end
-        i += 1
-      else
-        if @stop_on_unknown
-          remains += args[i .. -1]
-          return remains
-        else
-          remains << args[i]
-          i += 1
-        end
-      end
-    end
-    remains
-  end
-  def parse cmdline #:nodoc:
-    vals = {}
-    required = {}
-    found = {}
-    opt :version, "Print version and exit" if @version unless @specs[:version] || @long["version"]
-    opt :help, "Show this message" unless @specs[:help] || @long["help"]
-    @specs.each do |sym, opts|
-      required[sym] = true if opts[:required]
-      vals[sym] = opts[:default]
-    end
-    ## resolve symbols
-    args = []
-    @leftovers = each_arg cmdline do |arg, param|
-      sym =
-        case arg
-        when /^-([^-])$/
-          @short[$1]
-        when /^--([^-]\S*)$/
-          @long[$1]
-        else
-          raise CommandlineError, "invalid argument syntax: '#{arg}'"
-        end
-      raise CommandlineError, "unknown argument '#{arg}'" unless sym
-      raise CommandlineError, "option '#{arg}' specified multiple times" if found[sym]
-      args << [sym, arg, param]
-      found[sym] = true
-      @specs[sym][:type] != :flag # take params on all except flags
-    end
-    ## check for version and help args
-    raise VersionNeeded if args.any? { |sym, *a| sym == :version }
-    raise HelpNeeded if args.any? { |sym, *a| sym == :help }
-    ## check constraint satisfaction
-    @constraints.each do |type, syms|
-      constraint_sym = syms.find { |sym| found[sym] }
-      next unless constraint_sym
-      case type
-      when :depends
-        syms.each { |sym| raise CommandlineError, "--#{@specs[constraint_sym][:long]} requires --#{@specs[sym][:long]}" unless found[sym] }
-      when :conflicts
-        syms.each { |sym| raise CommandlineError, "--#{@specs[constraint_sym][:long]} conflicts with --#{@specs[sym][:long]}" if found[sym] && sym != constraint_sym }
-      end
-    end
-    required.each do |sym, val|
-      raise CommandlineError, "option '#{sym}' must be specified" unless found[sym]
-    end
-    ## parse parameters
-    args.each do |sym, arg, param|
-      opts = @specs[sym]
-      raise CommandlineError, "option '#{arg}' needs a parameter" unless param || opts[:type] == :flag
-      case opts[:type]
-      when :flag
-        vals[sym] = !opts[:default]
-      when :int
-        raise CommandlineError, "option '#{arg}' needs an integer" unless param =~ /^\d+$/
-        vals[sym] = param.to_i
-      when :float
-        raise CommandlineError, "option '#{arg}' needs a floating-point number" unless param =~ FLOAT_RE
-        vals[sym] = param.to_f
-      when :string
-        vals[sym] = param.to_s
-      end
-    end
-    vals
-  end
-  def width #:nodoc:
-    @width ||=
-      if $stdout.tty?
-        begin
-          require 'curses'
-          Curses::init_screen
-          x = Curses::cols
-          Curses::close_screen
-          x
-        rescue Exception
-          80
-        end
-      else
-        80
-      end
-  end
-  ## Print the help message to 'stream'.
-  def educate stream=$stdout
-    width # just calculate it now; otherwise we have to be careful not to
-          # call this unless the cursor's at the beginning of a line.
-    left = {}
-    @specs.each do |name, spec|
-      left[name] = "--#{spec[:long]}" +
-        (spec[:short] ? ", -#{spec[:short]}" : "") +
-        case spec[:type]
-        when :flag; ""
-        when :int; " <i>"
-        when :string; " <s>"
-        when :float; " <f>"
-        end
-    end
-    leftcol_width = left.values.map { |s| s.length }.max || 0
-    rightcol_start = leftcol_width + 6 # spaces
-    unless @order.size > 0 && @order.first.first == :text
-      stream.puts "#@version\n" if @version
-      stream.puts "Options:"
-    end
-    @order.each do |what, opt|
-      if what == :text
-        stream.puts wrap(opt)
-        next
-      end
-      spec = @specs[opt]
-      stream.printf "  %#{leftcol_width}s:   ", left[opt]
-      desc = spec[:desc] +
-        if spec[:default]
-          if spec[:desc] =~ /\.$/
-            " (Default: #{spec[:default]})"
-          else
-            " (default: #{spec[:default]})"
-          end
-        else
-          ""
-        end
-      stream.puts wrap(desc, :width => width - rightcol_start - 1, :prefix => rightcol_start)
-    end
-  end
-  def wrap_line str, opts={} # :nodoc:
-    prefix = opts[:prefix] || 0
-    width = opts[:width] || (self.width - 1)
-    start = 0
-    ret = []
-    until start > str.length
-      nextt =
-        if start + width >= str.length
-          str.length
-        else
-          x = str.rindex(/\s/, start + width)
-          x = str.index(/\s/, start) if x && x < start
-          x || str.length
-        end
-      ret << (ret.empty? ? "" : " " * prefix) + str[start ... nextt]
-      start = nextt + 1
-    end
-    ret
-  end
-  def wrap str, opts={} # :nodoc:
-    if str == ""
-      [""]
-    else
-      str.split("\n").map { |s| wrap_line s, opts }.flatten
-    end
-  end
-  ## instance_eval but with ability to handle block arguments
-  ## thanks to why: http://redhanded.hobix.com/inspect/aBlockCostume.html
-  def cloaker &b #:nodoc:
-    (class << self; self; end).class_eval do
-      define_method :cloaker_, &b
-      meth = instance_method :cloaker_
-      remove_method :cloaker_
-      meth
-    end
-  end
-end
-## The top-level entry method into Trollop. Creates a Parser object,
-## passes the block to it, then parses +args+ with it, handling any
-## errors or requests for help or version information appropriately
-## (and then exiting). Modifies +args+ in place. Returns a hash of
-## option values.
-##
-## The block passed in should contain one or more calls to #opt
-## (Parser#opt), one or more calls to text (Parser#text), and
-## probably a call to version (Parser#version).
-##
-## See the synopsis in README.txt for examples.
-def options args = ARGV, *a, &b
-  @p = Parser.new(*a, &b)
-  begin
-    vals = @p.parse args
-    args.clear
-    @p.leftovers.each { |l| args << l }
-    vals
-  rescue CommandlineError => e
-    $stderr.puts "Error: #{e.message}."
-    $stderr.puts "Try --help for help."
-    exit(-1)
-  rescue HelpNeeded
-    @p.educate
-    exit
-  rescue VersionNeeded
-    puts @p.version
-    exit
-  end
-end
-## Informs the user that their usage of 'arg' was wrong, as detailed by
-## 'msg', and dies. Example:
-##
-##   options do
-##     opt :volume, :default => 0.0
-##   end
-##
-##   die :volume, "too loud" if opts[:volume] > 10.0
-##   die :volume, "too soft" if opts[:volume] < 0.1
-##
-## In the one-argument case, simply print that message, a notice
-## about -h, and die. Example:
-##
-##   options do
-##     opt :whatever # ...
-##   end
-##
-##   Trollop::die "need at least one filename" if ARGV.empty?
-def die arg, msg=nil
-  if msg
-    $stderr.puts "Error: argument --#{@p.specs[arg][:long]} #{msg}."
-  else
-    $stderr.puts "Error: #{arg}."
-  end
-  $stderr.puts "Try --help for help."
-  exit(-1)
-end
-module_function :options, :die
-end # module