dialog-fu 0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 546f459f27e812bb284a2afeda60a26995655286
+  data.tar.gz: b7398666b2b26e12512143fec0afe4c5ae1526b1
+SHA512:
+  metadata.gz: 98327730998009bf20e0302ed6dccba9c7ae3849f64e234fab4024dcd88ea878c8f51fd4cadaf4c6781a17540bddb81b0c6458c93ab9c2bb926cebd650204f62
+  data.tar.gz: c94b88165cef7049f2a5d1bc618271b4cb83f5d0a05391db06d4738ff9ffa1b4f6a3d74629af8faff6fb57acb6261ce852c81f1e6407e688595e5c182572d5c7

data/.yardopts

@@ -0,0 +1,3 @@
+-o doc
+--title "Dialog-fu 0.2 Documentation"
+-m asciidoc

data/README.adoc

@@ -0,0 +1,53 @@
+= Dialog-fu
+Chris Riddoch <riddochc@gmail.com>
+:language: ruby
+
+Version 0.2, 2014-06-27
+
+== Description
+
+This library provides a high-level API for simple user interfaces with
+kdialog (forthcoming: dialog/zenity/yad/cocoadialog)
+
+Sometimes, being usable matters.  In addition to providing the world's most
+intricate command suite and option parsing for expert users, it might be nice
+to just give a little interface.  Not so much that you have to restructure
+your whole program around some GUI framework, but if you need a filename
+or a little text entry box or a confirmation box, the "dialog"-like programs
+can make the job a lot easier.
+
+This is intended to make it easy for you, as a programmer, to make your
+programs easier to use.  Everyone wins, right?
+
+Further documentation can be generated with by running 'rake'
+
+== Requirements
+
+Ruby 2.0 or newer
+
+One of:
+
+* kdialog
+
+In the future, other variations of the 'dialog' program will be supported.
+
+== Installation
+
+  gem install dialog-fu 
+
+== Use
+
+----
+require 'dialog-fu'
+
+Dialog.autosetup  # Figure out what implementation to use
+
+Dialog.messagebox("Hello, world")
+----
+
+== License
+
+Copyright © 2011-14 Chris Riddoch
+
+See lgpl-3.0.txt for license details
+

data/Rakefile

@@ -0,0 +1,25 @@
+require 'yard'
+require 'rake/testtask'
+require_relative './lib/dialog.rb'
+
+task :doc => :yard
+YARD::Rake::YardocTask.new do |t|
+  t.files   = ['lib/**/*.rb']
+end
+
+desc "Builds the gem"
+task :gem do
+  sh "gem build dialog-fu.gemspec"
+end
+
+desc "Installs the gem"
+task :install => :gem do
+  sh "gem install dialog-fu-#{Dialog::VERSION}.gem"
+end
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*_test.rb']
+end
+
+task :default => [:test]

data/dialog-fu.gemspec

@@ -0,0 +1,22 @@
+require './lib/dialog'
+
+spec = Gem::Specification.new do |s| 
+  s.name = 'dialog-fu'
+  s.version = Dialog::VERSION
+  s.author = 'Chris Riddoch'
+  s.email = 'riddochc@gmail.com'
+  s.homepage = 'http://syntacticsugar.org/software/dialog-fu/'
+  s.description = "A high-level API for simple user interfaces with dialog programs"
+  s.license = 'LGPL-3.0'
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'Extracts information from tables in documents'
+  s.files = Dir.glob("{docs,bin,lib,spec,templates,benchmarks}/**/*") +
+            ['lgpl-3.0.txt', 'README.adoc', 'Rakefile', '.yardopts', __FILE__]
+  s.require_paths = ['lib']
+  s.has_rdoc = 'yard'
+  s.extra_rdoc_files = ['README.adoc']
+  s.required_ruby_version = '>= 2.0.0'
+  s.add_development_dependency('rake', '~> 10.0', '>= 10.0.0')
+  s.add_development_dependency('yard', '~> 0.8', '>= 0.8.7.3')
+end
+

data/lgpl-3.0.txt

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/lib/dialog-fu.rb

@@ -0,0 +1 @@
+require_relative 'dialog'

data/lib/dialog.rb

@@ -0,0 +1,10 @@
+module Dialog
+  VERSION='0.2'
+end
+
+require_relative "dialog/dialog"
+require_relative "dialog/kdialog"
+require_relative "dialog/zenity"
+require_relative "dialog/yad"
+require_relative "dialog/cocoadialog"
+require_relative "dialog/main" # needs to be loaded last, so things can be imported properly.

data/lib/dialog/cocoadialog.rb

@@ -0,0 +1,2 @@
+module Dialog::CocoaDialog
+end

data/lib/dialog/dialog.rb

@@ -0,0 +1,2 @@
+module Dialog::Dialog
+end

data/lib/dialog/kdialog.rb

@@ -0,0 +1,344 @@
+require 'open3'
+require 'tempfile'
+
+module Dialog::KDialog
+
+  # Standard dialog boxes
+  # 
+  # The valid combinations of boolean parameters specifying the type of buttons available are as follows:
+  #
+  # [cols="4"]
+  # |===
+  # |*YesNo*
+  # |*Cancel*
+  # |*Warning*
+  # |*Continue*
+  #
+  # | true
+  # | true
+  # | true
+  # | false
+  #
+  # | true
+  # | true
+  # | false
+  # | false
+  #
+  # | true
+  # | false
+  # | false
+  # | false
+  #
+  # | true
+  # | false
+  # | true
+  # | false
+  #
+  # | false
+  # | true
+  # | true
+  # | true
+  # |===
+  #
+  # @param text [String] The text presented to the user above buttons.
+  # @param yesno [Boolean] If true, show "Yes" and "No" buttons.
+  # @param cancel [Boolean] If true, show a "Cancel" button.
+  # @param continue_btn [Boolean] If true, show a "Continue" button.
+  # @param warning [Boolean] If true, the icon shown is a warning icon, not a standard question icon
+  # @yield [] If the user makes a positive selection (yes or continue), the given
+  #   block is called.  If not, the block is ignored.
+  def dialogbox(text, yesno: true, cancel: false, continue_btn: false, warning: false)
+    valid_dialogs = {"warningyesnocancel" => true, "yesnocancel" => true,
+                     "yesno" => true, "warningyesno" => true,
+                     "warningcontinuecancel" => true}
+    cmd = ""
+    cmd += "warning" if warning == true
+    cmd += "yesno" if yesno == true
+    cmd += "continue" if continue_btn == true
+    cmd += "cancel" if cancel == true
+    unless valid_dialogs.has_key?(cmd)
+      raise "Can't make that kind of dialog box"
+    end
+    cmd = "--#{cmd}"
+    out, status = *run([cmd, text])
+    if block_given? and status == true
+      yield()
+    end
+  end
+
+  # A message box, for displaying a little text to the user.  
+  # For longer, multi-line text, you may prefer to use #textbox.
+  # Contrasting with the standard dialog boxes, the button presented to the user
+  #   only has the effect of closing the box.
+  #
+  # @param type [:msgbox :sorry :error] The type of message box, affects the choice of icon shown in the box
+  # @!macro [new] runreturn
+  #   @return [Array<(String, Boolean)>]  the textual output of running kdialog, and whether it exited successfully
+  def messagebox(text, type: :msgbox)
+    unless {:msgbox => 1, :sorry => 1, :error => 1}.has_key?(type)
+      raise "Can't make that kind of message box"
+    end
+    cmdtype = "--#{type}"
+    run([cmdtype, text])
+  end
+
+  # A window for showing the user a large amount of text, potentially using
+  # horizontal and vertical scrollbars.  For small amounts of text, use #messagebox
+  #
+  # @param text [String IO] The text to send to the user, or a readable IO object.
+  # @param height [Integer] The height of the textbox area, defaults to 10
+  # @param width [Integer] The width of the textbox area, defaults to 40
+  # @macro runreturn
+  def textbox(text, height: 10, width: 40)
+    Tempfile.open('dialogfu') do |tf|
+      if text.respond_to?(:read)
+        tf.print(text.read)
+      else
+        tf.print(text)
+      end
+      tf.close
+      run(["--textbox", path, "--height", height, "--width", width])
+      tf.unlink
+    end
+  end
+
+  # Present an input box.  It may be a one-line field, a password field, or a larger text-entry area potentially with scrollbars.
+  #
+  # @param prompt [String] The text to prompt the user, above the input fields
+  # @param content [String] The initial value in the input box
+  # @param height [Integer] The height of the input field.  If 1, presents a single-line input field.
+  #   If larger, presents a text box that can potentially scroll vertically and horizontally.  Defaults to 1
+  # @param width [Integer] The width of the input field.  Note that this does not limit the amount of text
+  #   the user may return, only how much can be seen on the screen at once.
+  # @param password [Boolean] When true, use a 'key' icon and only show dots in place of input characters.
+  #   When this is true, the height parameter is required to be 1, otherwise this option has no effect.
+  # @yieldparam input [String] the text provided by the user
+  # @macro runreturn
+  def inputbox(prompt: "Input some text", content: nil, height: 1, width: 40, password: false, &blk)
+    if height == 1
+      if password == true
+        cmd = ["--password"]
+      else
+        cmd = ["--inputbox"]
+      end
+    elsif height > 1
+      cmd = ["--textinputbox"]
+    end
+    cmd << prompt
+    if password == false
+      cmd << content if content
+      if height > 1
+        cmd += ["--height", height]
+      end
+      cmd += ["--width", 40]
+    end
+
+    run(cmd, &blk)
+  end
+
+  # @!macro [new] labelparam
+  #   @param label [String] The text to display above input fields
+  # @!macro [new] choiceparam
+  #   @param choices [#members] An object with an attribute for each choice, and a +#members+ method which
+  #     returns a list of those attributes to be used.
+
+  # A dropdown box
+  #
+  # This is similar to a radio button selection; only one selection can be made.
+  #
+  # @macro choiceparam
+  # @macro labelparam
+  #
+  def combobox(choices, label: "")
+    cmd = ["--combobox", label] + choices.members.map {|k| k.to_s}
+    run(cmd) {|sel|
+      selected = (sel + '=').to_sym
+      (choices.members - [selected]).each {|c| choices.send((c.to_s + '=').to_sym, false)}
+      choices.send(selected, true)
+    }
+  end
+
+  # Present a set of checkboxes to the user
+  #
+  # Using this method may be easier than using #selection, as you don't need to indicate you want checkboxes.
+  #
+  # @macro choiceparam
+  # @macro labelparam
+  # @!macro [new] defaultparam
+  #   @param default [Array<String> String] The name of the attribute to be pre-selected for the user,
+  #     or a list of such names, in the case of checkboxes.  If not provided, the attribute's value is
+  #     tested, and if true, is selected.
+  # @example Using a Struct for checkboxes
+  #   Foodselection = Struct.new(:salad, :soup, :sandwich, :cookie, :drink)
+  #   choices = Foodselection.new(false, false, true, false, true)  # sandwich and drink preselected
+  #   checkboxes(choices, label: "What would you like for lunch?")
+  # @macro runreturn
+  #
+  def checkboxes(choices, label: "", default: nil)
+    selection(choices, label: label, type: :check, default: default)
+  end
+
+  # Present a set of radio buttons to the user
+  #
+  # Using this method may be easier than using #selection, as you don't need to indicate you want radio buttons.
+  # 
+  # @macro choiceparam
+  # @macro labelparam
+  # @macro defaultparam
+  # @macro runreturn
+  # @note It's the caller's responsibility to either specify a default,
+  #   or make sure only one of the 'choices' attributes is true in the +choices+ parameter.
+  def radiobuttons(choices, label: "", default: nil)
+    selection(choices, label: label, type: :radio, default: default)
+  end
+
+  # @macro choiceparam
+  # @macro labelparam
+  # @macro defaultparam
+  # @param type [Symbol] Either :check (for checkboxes, multiple selections allowed) or :radio, (for
+  #   radio buttons, only one selection)
+  # @raise UnknownSelectionType If type is something other than :check or :radio
+  # @macro runreturn
+  #
+  # @note If +type+ is +:radio+, it's the caller's responsibility to either specify a default,
+  #   or make sure only one of the 'choices' attributes is true in the +choices+ parameter.
+  def selection(choices, label: "", type: :check, default: nil)
+    cmd = ["--separate-output"]
+    cmd << case type
+    when :check
+      "--checklist"
+    when :radio
+      "--radiolist"
+    else
+      raise UnknownSelectionType, "Unknown selection type", caller
+    end
+    cmd << label
+    choices.members.each_with_index {|c, i|
+      if ((default.nil? and choices.send(c)) or (default == c) or (default.include?(c)))
+          cmd += [i.to_s, c.to_s, 'on']
+      else
+        cmd += [i.to_s, c.to_s, 'off']
+      end
+    }
+    run(cmd) do |sel|
+      selected = sel.each_line.map{|l| l.chomp.to_i}
+      choices.members.each.with_index do |box, i|
+        method = (box.to_s + '=').to_sym
+        if selected.include?(i)
+          choices.send(method, true)
+        else
+          choices.send(method, false)
+        end
+      end
+    end
+  end
+
+  # Raise a notification for the user. This doesn't bring up a window that takes focus,
+  # just a little box (usually above the taskbar) in the notification area that goes away by itself.
+  #
+  # @param text [String] The text to show in the notification
+  # @param timeout [Integer] The number of seconds to show the notification for
+  def notification(text, timeout: 3)
+    run(["--passivepopup", text, timeout.to_s])
+  end
+
+  # Present a file-picker box, for getting filenames or URLs from the user, for saving or opening.
+  # 
+  # @param action [Symbol] One of :save or :open
+  # @param type [Symbol] One of :url, :file, or :directory, indicating what kind of input is expected from the user
+  # @param dir [String] Directory to start the UI in, defaults to ENV['HOME']
+  # @param multiple [Boolean] If true, allow the user to select multiple files. Only works when action is :open.
+  # @param filter [String] A description of what types of files should be displayed in directory listings
+  # @yieldparam path [Array<String> String] The path (or paths) selected by the user
+  # @return [Array<String> String] The path (or paths) selected by the user
+  # @todo Figure out what kinds of strings are expected of the filter parameter, write code to validate
+  def filepicker(action: :save, type: :file, dir: ENV['HOME'], multiple: false, filter: nil, &blk)
+    cmd = ["--separate-output"]
+    cmd << "--multiple" if (multiple and action == :open)
+    cmd << case [action, type]
+    when [:save, :file]
+      "--getsavefilename"
+    when [:save, :url]
+      "--getsaveurl"
+    when [:open, :file]
+      "--getopenfilename"
+    when [:open, :url]
+      "--getopenurl"
+    else
+      if type == :directory
+        "--getexistingdirectory"
+      end
+    end
+    cmd << dir
+    cmd << filter unless (type == :directory or filter.nil?)
+    if block_given?
+      run(cmd) do |input|
+        if multiple
+          param = input.split(/\n/)
+        else
+          param = input
+        end
+        yield(param)
+      end
+    else
+      input, status = run(cmd)
+      if multiple
+        input.split(/\n/)
+      else
+        input
+      end
+    end
+  end
+
+  # @todo Implement
+  # Known groups for iconloader (on my system, anyway):
+  #
+  # * Desktop, Toolbar, MainToolbar, Small, Panel, Dialog, User, Action, Application, Device, FileSystem, MimeType, Animation, Category, Emblem, Emote, International, Place, StatusIcon
+  # * From KDE3: Devices, MimeTypes, Applications, Actions
+  def icon()
+  end
+
+  # @todo Design and implement API for using progressbar
+  def progressbar()
+    require 'dbus' unless DBus
+    steps = 10
+    out, status = Open3.capture2("kdialog", "--progressbar", "Titlebar Text", steps.to_s)
+    if status != 0
+      raise "kdialog exited unexpectedly"
+    end
+    servicename, path = *out.split(/\s+/)
+
+    bus = DBus::SessionBus.instance
+    dialogservice = bus.service(servicename)
+    dialogobj =  dialogservice.object(path)
+    d = dialogobj["org.kde.kdialog.ProgressDialog"]
+
+    d.showCancelButton(true) # or false...
+    r = d.wasCancelled
+    r.first # the boolean.  Why it's in an array? Dunno.
+    d["maximum"] # => 10
+    d["autoClose"] # => false, by default
+    d.setLabelText("Test")
+    d["value"] # Can be assigned! Yay!  Ignored if out of range.
+    d.close # When done!
+  end
+
+  # @api private
+  # @param arglist [Array<String>] List of command-line arguments for kdialog
+  # @raise [StandardError] Any exception raised by Open3#capture2
+  # @yieldparam output [String] The output of running kdialog
+  # @macro runreturn
+  def run(arglist, &blk)
+    cmd = ["kdialog"] + arglist
+    output, code = Open3.capture2(*cmd)
+    status = case code.exitstatus
+             when 0 then true
+             when 1 then false
+             else false
+             end
+    if block_given? and status == true
+      yield(output.chomp)
+    end
+    return output.chomp, status
+  end
+end

data/lib/dialog/main.rb

@@ -0,0 +1,53 @@
+module Dialog
+
+  # Figure out which implementation of dialog to use, based on platform detection.
+  # This loads the methods from more specific submodules into this Dialog module, so that
+  # you can just call (for example) Dialog.messagebox("Hello, world.")
+  def self.autosetup
+    case RUBY_PLATFORM
+    when /linux/
+      if ENV.fetch('DISPLAY', "").length > 0
+        kdepid = IO.popen(["pidof", "-s", "kdeinit", "kdeinit4"], 'r') do |io|
+          io.read
+        end
+        to_run = ["kdialog", "yad", "zenity", "dialog"].map {|name|
+          name if ENV['PATH'].split(/:/).detect {|dir| File.exists?(File.join(dir, name)) }
+        }.compact
+
+        if kdepid != "" and to_run.include?("kdialog")
+          extend KDialog  # Already running KDE?
+        else
+          if to_run.include?("yad")
+            extend Yad
+          elsif to_run.include?("zenity")
+            extend Zenity
+          elsif to_run.include?("kdialog")
+            extend KDialog
+          elsif (to_run.include?("dialog") and $stdout.isatty)
+            extend Dialog
+          end
+        end
+      else
+        extend Dialog if ($stdout.isatty and $stdin.isatty)
+      end
+    when /darwin/
+      extend CocoaDialog
+    when /mingw/
+      to_run = ["yad", "zenity", "dialog"].map {|name|
+        name if ENV['PATH'].split(/;/).detect {|dir| File.exists?(File.join(dir, name)) }
+      }.compact
+      case to_run.first
+      when 'yad'
+        extend Yad
+      when 'zenity'
+        extend Zenity
+      when 'dialog'
+        extend Dialog
+      else
+        # Not sure here, any other way to get a dialog on windows?
+      end
+    else
+      # The user will just have to load it themselves.
+    end
+  end
+end

data/lib/dialog/yad.rb

@@ -0,0 +1,2 @@
+module Dialog::Yad
+end

data/lib/dialog/zenity.rb

@@ -0,0 +1,2 @@
+module Dialog::Zenity
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: dialog-fu
+version: !ruby/object:Gem::Version
+  version: '0.2'
+platform: ruby
+authors:
+- Chris Riddoch
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.0.0
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.7.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.7.3
+description: A high-level API for simple user interfaces with dialog programs
+email: riddochc@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.adoc
+files:
+- ".yardopts"
+- README.adoc
+- Rakefile
+- dialog-fu.gemspec
+- lgpl-3.0.txt
+- lib/dialog-fu.rb
+- lib/dialog.rb
+- lib/dialog/cocoadialog.rb
+- lib/dialog/dialog.rb
+- lib/dialog/kdialog.rb
+- lib/dialog/main.rb
+- lib/dialog/yad.rb
+- lib/dialog/zenity.rb
+homepage: http://syntacticsugar.org/software/dialog-fu/
+licenses:
+- LGPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Extracts information from tables in documents
+test_files: []
+has_rdoc: yard